How Can I Get Title of a Chrome Processes?

Question

Google Chrome places each tab into a separate process. Only the currently selected tab has it's Process.MainWindowTitle set to the current tab's title. The other tab's do not contain this information.

Is there a way to find out the Title of each tabs from the processes?

or... get pid of 'tabs' process?

Sam Hobbs · Answer

If it were me I would look at the Chrome documentation. There should be an API or something such as that for getting the information. Also I vaguely remember answering a question such as this before. I think one possible way would be to find the process that owns the window (that we see that has the tabs) then enumerate the tabs in that window. I don't know the details of how to do that but I could figure it out if I had to. I would first try to do as I said above; use whatever that Google has provided and documented unless that is not possible.

Sam Hobbs · Answer

We have not heard from Chang Hee Lee so I will assume the problem is solved.

Vulpes · Answer

It's the inactive tabs which are the problem :) My two efforts did get the titles of these but I wasn't happy with them because they depended on hacks in order to work. However I've just been looking at Google Chrome again with Spy++ and - I don't know how I missed it before but - all the inactive tabs are simply child windows of one of the inactive top level windows!! This means it's now trivially easy to get all the titles the only remaining problem being that they're not necessarily recovered in the right order: using System; using System.Collections.Generic; using System.Diagnostics; using System.Runtime.InteropServices; using System.Text; class Program { [DllImport(user32.dll)] static extern IntPtr FindWindowEx(IntPtr hwndParent IntPtr hwndChildAfter string lpszClass string lpszWindow); [DllImport(user32.dll CharSet = CharSet.Auto)] static extern int GetWindowText(IntPtr hWnd StringBuilder lpString int nMaxCount); static void Main() { Process[] procs = Process.GetProcessesByName(chrome); if (procs.Length == 0) { Console.WriteLine(Google Chrome is not currently open); return; } List titles = new List (); IntPtr hWnd = IntPtr.Zero; foreach(Process p in procs) { if(p.MainWindowTitle.Length > 0) { hWnd = p.MainWindowHandle; break; } } IntPtr parentPtr = IntPtr.Zero; IntPtr childPtr = IntPtr.Zero; StringBuilder sb = new StringBuilder(256); while(true) { parentPtr = FindWindowEx(IntPtr.Zero parentPtr Chrome_WidgetWin_0 null); if (parentPtr == IntPtr.Zero) break; while(true) { childPtr = FindWindowEx(parentPtr childPtr Chrome_WidgetWin_0 null); if (childPtr == IntPtr.Zero) break; sb.Length = 0; GetWindowText(childPtr sb 256); titles.Add(sb.ToString()); } } for(int i = 0; i { Console.WriteLine({0}. {1}
 i + 1 titles[i]); // list titles to console } Console.ReadKey(); } }

Sam Hobbs · Answer

I still can't find the relevant Chrome API but I assume there is one. If however we must use Windows then I notice that there is always one Windows window for each visible Chrome browser window that has the title of the active tab and then there is a second window for the inactive tabs of each browser window. I am not sure how to detect the window with the inactive tabs but the window with the active tab always has  - Google Chrome at the end of the title. So the following program can find all the active tabs. It uses EnumWindows to enumerate all top-level windows. It ignores windows that are not visible. It then checks for windows with a class name of Chrome_WidgetWin_0. If a window qualifies up to there then it checks to see if the title ends with  - Google Chrome. If it does then the window is added to a list and the list is shown later. using System; using System.Text; using System.Collections.Generic; using System.Runtime.InteropServices; namespace _130251_how_can_i_get_title_of_a_chrome_processes { class Program { const String ChromeClassName = Chrome_WidgetWin_0; const String GoogleChromeSuffix =  - Google Chrome; [DllImport(user32.dll)] private static extern int GetWindowText(int hWnd StringBuilder title int size); [DllImport(user32.dll)] private static extern int GetClassName(int hWnd StringBuilder ClassName int size); [DllImport(user32.dll)] private static extern int EnumWindows(EnumWindowsProc ewp int lParam); [DllImport(user32.dll)] private static extern bool IsWindowVisible(int hWnd); public delegate bool EnumWindowsProc(int hWnd int lParam); static List ChromeMainWindows = new List (); static void Main(string[] args) { EnumWindowsProc ewp = new EnumWindowsProc(FindChromeMains); EnumWindows(ewp 0); foreach (Window cw in ChromeMainWindows) OtherTabs(cw); } private static void OtherTabs(Window mw) { Console.WriteLine(mw.Title); } static private bool FindChromeMains(int hWnd int lParam) { if (!IsWindowVisible(hWnd)) return (true); StringBuilder ClassNameStringBuilder = new StringBuilder(256); GetClassName(hWnd ClassNameStringBuilder 256); String ClassName = ClassNameStringBuilder.ToString(); if (ClassName != ChromeClassName) return (true); StringBuilder WindowText = new StringBuilder(256); GetWindowText(hWnd WindowText 256); if (WindowText.Length == 0) return (true); String Title = WindowText.ToString(); if (Title.EndsWith(GoogleChromeSuffix)) ChromeMainWindows.Add(new Window(Title (IntPtr)hWnd)); return (true); } } public class Window { public IntPtr hWnd; public string Title; public Window(string Title IntPtr hWnd) { this.Title = Title; this.hWnd = hWnd; } } }

Vulpes · Answer

I've figured out a better way of doing this which makes use of the Google Chrome Task Manager. This pops up when you press SHIFT + ESC and lists the various pages including the tabs which can be easily identified because they begin with Tab: . After using Spy++ to find out the class names of the various windows I've come up with the following code. Notice though that if you're running this from a 64-bit system you'll need to compile for the x86 platform otherwise it won't work correctly (the titles will be blank): using System; using System.Collections.Generic; using System.Diagnostics; using System.Windows.Forms; using System.Runtime.InteropServices; using System.Threading; [StructLayoutAttribute(LayoutKind.Sequential)] struct LVITEM { public uint mask; public int iItem; public int iSubItem; public uint state; public uint stateMask; public IntPtr pszText; public int cchTextMax; public int iImage; public IntPtr lParam; public int iIndent; } class Test { const int LVM_FIRST = 0x1000; const int LVM_GETITEMCOUNT = LVM_FIRST + 4; const int LVM_GETITEMTEXT = LVM_FIRST + 45; const int PROCESS_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFF; const uint MEM_COMMIT = 0x1000; const uint MEM_RELEASE = 0x8000; const uint PAGE_READWRITE = 0x4; const int STANDARD_RIGHTS_REQUIRED = 0xF0000; const int SYNCHRONIZE = 0x100000; [DllImport(user32.dll)] static extern bool SetForegroundWindow(IntPtr hWnd); [DllImport(user32.dll)] static extern bool IsIconic(IntPtr hWnd); [DllImport(user32.dll)] static extern bool ShowWindow(IntPtr hWnd int nCmdShow); [DllImport(user32.dll)] static extern IntPtr FindWindow(string lpClassName string lpWindowName); [DllImport(user32.dll)] static extern IntPtr FindWindowEx(IntPtr hwndParent IntPtr hwndChildAfter string lpszClass string lpszWindow); [DllImport(kernel32.dll)] static extern IntPtr OpenProcess(uint dwDesiredAccess bool bInheritHandle uint dwProcessId); [DllImport(user32.dll)] private static extern IntPtr SendMessage(IntPtr hWnd int Msg int wParam IntPtr lParam); [DllImport(kernel32)] static extern IntPtr VirtualAllocEx(IntPtr hProcess IntPtr lpAddress int dwSize uint flAllocationType uint flProtect); [DllImport(kernel32)] static extern bool VirtualFreeEx(IntPtr hProcess IntPtr lpAddress int dwSize uint dwFreeType); [DllImport(kernel32.dll)] static extern bool ReadProcessMemory(IntPtr hProcess IntPtr lpBaseAddress IntPtr lpBuffer uint size out int lpNumberOfBytesRead); [DllImport(kernel32)] static extern bool WriteProcessMemory(IntPtr hProcess IntPtr lpBaseAddress ref LVITEM buffer int dwSize IntPtr lpNumberOfBytesWritten); static void Main() { Process[] procs = Process.GetProcessesByName(chrome); if (procs.Length == 0) { Console.WriteLine(Google Chrome is not currently open); return; } List titles = new List (); IntPtr hWnd = IntPtr.Zero; int id = 0; foreach(Process p in procs) { if(p.MainWindowTitle.Length > 0) { hWnd = p.MainWindowHandle; id = p.Id; break; } } bool isMinimized = IsIconic(hWnd); if (isMinimized) { ShowWindow(hWnd 9); // restore Thread.Sleep(100); } SetForegroundWindow(hWnd); // set focus to Google Chrome SendKeys.SendWait(+{ESC}); // pop up Chrome Task Manager window Thread.Sleep(100); IntPtr hTaskManager = FindWindow(Chrome_WidgetWin_0 Task Manager - Google Chrome); // get handle of Task Manager IntPtr hContainer = FindWindowEx(hTaskManager IntPtr.Zero ChromeViewsNativeControlContainer null); // get handle of controls container IntPtr hListView = FindWindowEx(hContainer IntPtr.Zero SysListView32 null); // get handle of ListView int lviCount = (int)SendMessage(hListView LVM_GETITEMCOUNT 0 IntPtr.Zero); // get number of items in ListView IntPtr hProcess = OpenProcess(PROCESS_ALL_ACCESS false (uint)id); // get process handle IntPtr lviPtr = VirtualAllocEx(hProcess IntPtr.Zero Marshal.SizeOf(typeof(LVITEM)) MEM_COMMIT PAGE_READWRITE); // allocate process memory for LVITEM IntPtr textPtr = VirtualAllocEx(hProcess IntPtr.Zero 512 MEM_COMMIT PAGE_READWRITE); // allocate process memory for text LVITEM lvi = new LVITEM(); // create LVITEM struct lvi.cchTextMax = 512; // set text buffer length to 512 bytes lvi.pszText = textPtr; // set pointer to text buffer int bytesRead; IntPtr hGlobal = Marshal.AllocHGlobal(512); // allocate local memory for text WriteProcessMemory(hProcess lviPtr ref lvi Marshal.SizeOf(typeof(LVITEM)) IntPtr.Zero); // write LVITEM struct to process memory for (int i = 0; i { SendMessage(hListView LVM_GETITEMTEXT i lviPtr); // get text for 'i'th row of ListView and put it in process buffer ReadProcessMemory(hProcess textPtr hGlobal 512 out bytesRead); // copy text from process buffer to local buffer string title = Marshal.PtrToStringAnsi(hGlobal); // convert text to unicode string if (title.StartsWith(Tab: )) // if it's a tab { title = title.Substring(5).Replace( - Google Chrome ); // strip to basic title titles.Add(title); //add to titles list } } VirtualFreeEx(hProcess lviPtr 0 MEM_RELEASE); // free process memory VirtualFreeEx(hProcess textPtr 0 MEM_RELEASE); // ditto Marshal.FreeHGlobal(hGlobal); // free local memory SendKeys.SendWait(%{F4}); // close Chrome Task Manager window Thread.Sleep(100); if(isMinimized) { ShowWindow(hWnd 6); // minimize again Thread.Sleep(100); } hWnd = Process.GetCurrentProcess().MainWindowHandle; SetForegroundWindow(hWnd); // change focus back to this program's window Thread.Sleep(100); for(int i = 0; i { Console.WriteLine({0}. {1}
 i + 1 titles[i]); // list titles to console } Console.ReadKey(); } }

Vulpes · Answer

TBH I'm not sure that the above approach is worthy of an article. Let's wait and see if Sam or some one else who's familiar with how Google Chrome works can come up with something better.

Suthish Nair · Answer

Vulpes we need an article on this :)

Vulpes · Answer

Well it's not very pretty but I've come up with a way to do this by programatically switching between the tabs and then reading the tab title. If Chrome is minimized I've restored it first and then minimized it again after the information has been extracted. The information is extracted in tab order starting with the first. Curiously the active tab always has the same process id - the other processes seem to just be running in the background. You can't therefore use the process id to signal when you've cycled back to the first tab. Nor can you use the tab title as there may of course be several tabs opened from the same url. However it appears that as well as there being one process for each tab there are also 4 other Chrome processes which run in the background. So if there's only one tab then there are 5 processes. I've used this (apparent) fact to deduce how many tabs there are. I've also had to insert small delays here and there (using Thread.Sleep) to ensure the various API calls and SendKeys are synchronized properly. Here's the code: using System; using System.Collections.Generic; using System.Diagnostics; using System.Windows.Forms; using System.Runtime.InteropServices; using System.Threading; class Test { [DllImport(user32.dll)] static extern bool SetForegroundWindow(IntPtr hWnd); [DllImport(user32.dll)] static extern bool IsIconic(IntPtr hWnd); [DllImport(user32.dll)] static extern bool ShowWindow(IntPtr hWnd int nCmdShow); static void Main() { Process[] procs = Process.GetProcessesByName(chrome); if (procs.Length == 0) { Console.WriteLine(Google Chrome is not currently open); return; } List titles = new List (); IntPtr hWnd = IntPtr.Zero; int id = 0; int numTabs = procs.Length - 4; // assuming there are 4 other processes apart from the tabs foreach(Process p in procs) { if(p.MainWindowTitle.Length > 0) { hWnd = p.MainWindowHandle; id = p.Id; break; } } bool isMinimized = IsIconic(hWnd); if (isMinimized) { ShowWindow(hWnd 9); // restore Thread.Sleep(100); } SetForegroundWindow(hWnd); SendKeys.SendWait(^1); // change focus to first tab Thread.Sleep(100); int next = 1; string title; while (next { title = Process.GetProcessById(id).MainWindowTitle.Replace( - Google Chrome ); titles.Add(title); next++; SendKeys.SendWait(^{TAB}); // change focus to next tab Thread.Sleep(100); } if(isMinimized) { ShowWindow(hWnd 6); // minimize again Thread.Sleep(100); } hWnd = Process.GetCurrentProcess().MainWindowHandle; SetForegroundWindow(hWnd); Thread.Sleep(100); for(int i = 0; i { Console.WriteLine({0}. {1}
 i + 1 titles[i]); } Console.ReadKey(); } }

Chang Hee Lee · Answer

ah thanks however I want get pid of [Only] Tab Process. I can't solve it ...

Vulpes · Answer

I haven't been able to figure out how to get the tab titles but you can get the process Ids easily enough with the following code: using System; using System.Diagnostics; class Test { static void Main() { Process[] procs = Process.GetProcessesByName(chrome); if (procs.Length == 0) { Console.WriteLine(Google Chrome is not currently open); return; } Console.WriteLine(The Process Ids for the {0} Google Chrome processes currently open are:
 procs.Length); foreach(Process proc in procs) { Console.WriteLine(proc.Id); } Console.ReadKey(); } }