Remove "from all browsers" memory details mode

chrome/browser/memory_details.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/memory_details.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 115 matching lines @@
 // This operation will hit no fewer than 3 threads.
 //
 // The BrowserChildProcessHostIterator can only be accessed from the IO thread.
 //
 // The RenderProcessHostIterator can only be accessed from the UI thread.
 //
 // This operation can take 30-100ms to complete.  We never want to have
 // one task run for that long on the UI or IO threads.  So, we run the
 // expensive parts of this operation over on the blocking pool.
 //
-void MemoryDetails::StartFetch(CollectionMode mode) {
+void MemoryDetails::StartFetch() {
   // This might get called from the UI or FILE threads, but should not be
   // getting called from the IO thread.
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // In order to process this request, we need to use the plugin information.
   // However, plugin process information is only available from the IO thread.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&MemoryDetails::CollectChildInfoOnIOThread, this, mode));
+      base::Bind(&MemoryDetails::CollectChildInfoOnIOThread, this));
 }
 
 MemoryDetails::~MemoryDetails() {}
 
 std::string MemoryDetails::ToLogString() {
   std::string log;
   log.reserve(4096);
   ProcessMemoryInformationList processes = ChromeBrowser()->processes;
   // Sort by memory consumption, low to high.
   std::sort(processes.begin(), processes.end());
@@ skipping 20 matching lines @@
                         static_cast<int>(iter1->working_set.shared) / 1024);
 #if defined(OS_CHROMEOS)
     log += StringPrintf(", %d MB swapped",
                         static_cast<int>(iter1->working_set.swapped) / 1024);
 #endif
     log += "\n";
   }
   return log;
 }
 
-void MemoryDetails::CollectChildInfoOnIOThread(CollectionMode mode) {
+void MemoryDetails::CollectChildInfoOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   std::vector<ProcessMemoryInformation> child_info;
 
   // Collect the list of child processes. A 0 |handle| means that
   // the process is being launched, so we skip it.
   for (BrowserChildProcessHostIterator iter; !iter.Done(); ++iter) {
     ProcessMemoryInformation info;
     if (!iter.GetData().handle)
       continue;
     info.pid = base::GetProcId(iter.GetData().handle);
     if (!info.pid)
       continue;
 
     info.process_type = iter.GetData().process_type;
     info.renderer_type = ProcessMemoryInformation::RENDERER_UNKNOWN;
     info.titles.push_back(iter.GetData().name);
     child_info.push_back(info);
   }
 
   // Now go do expensive memory lookups on the blocking pool.
   BrowserThread::GetBlockingPool()->PostWorkerTaskWithShutdownBehavior(
       FROM_HERE,
-      base::Bind(&MemoryDetails::CollectProcessData, this, mode, child_info),
+      base::Bind(&MemoryDetails::CollectProcessData, this, child_info),
       base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
 }
 
 void MemoryDetails::CollectChildInfoOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ProcessData* const chrome_browser = ChromeBrowser();
 
   // First pass, collate the widgets by process ID.
   std::map<base::ProcessId, std::vector<RenderWidgetHost*>> widgets_by_pid;
   scoped_ptr<content::RenderWidgetHostIterator> widget_it(
@@ skipping 123 matching lines @@
   // Get rid of other Chrome processes that are from a different profile.
   auto is_unknown = [](ProcessMemoryInformation& process) {
     return process.process_type == content::PROCESS_TYPE_UNKNOWN;
   };
   auto& vector = chrome_browser->processes;
   vector.erase(std::remove_if(vector.begin(), vector.end(), is_unknown),
                vector.end());
 
   OnDetailsAvailable();
 }