Return unique_ptrs from base::ProcessMetrics.

chrome/browser/task_manager/task_manager.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/task_manager/task_manager.h"
 
 #include "base/bind.h"
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
 #include "base/location.h"
@@ skipping 24 matching lines @@
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_navigator_params.h"
 #include "chrome/browser/ui/user_manager.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/nacl/browser/nacl_browser.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
+#include "content/public/browser/browser_child_process_host.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/gpu_data_manager_observer.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/worker_service.h"
 #include "content/public/common/result_codes.h"
 #include "extensions/browser/extension_system.h"
 #include "third_party/icu/source/i18n/unicode/coll.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/text/bytes_formatting.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/resources/grit/ui_resources.h"
 
-#if defined(OS_MACOSX)
-#include "content/public/browser/browser_child_process_host.h"
-#endif
-
-#if defined(OS_WIN)
-#include "chrome/browser/win/private_working_set_snapshot.h"
-#endif
-
 using content::BrowserThread;
 using content::ResourceRequestInfo;
 using content::WebContents;
 using task_manager::Resource;
 using task_manager::ResourceProvider;
 using task_manager::WebContentsInformation;
 
 class Profile;
 
 namespace {
@@ skipping 49 matching lines @@
     case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN:
     case IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN:
     case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN:
     case IDS_TASK_MANAGER_NACL_DEBUG_STUB_PORT_COLUMN:
       return true;
     default:
       return false;
   }
 }
 
-#if defined(OS_WIN)
-void GetWinGDIHandles(base::ProcessHandle process,
-                      size_t* current,
-                      size_t* peak) {
-  *current = 0;
-  *peak = 0;
-  // Get a handle to |process| that has PROCESS_QUERY_INFORMATION rights.
-  HANDLE current_process = GetCurrentProcess();
-  HANDLE process_with_query_rights;
-  if (DuplicateHandle(current_process, process, current_process,
-                      &process_with_query_rights, PROCESS_QUERY_INFORMATION,
-                      false, 0)) {
-    *current = GetGuiResources(process_with_query_rights, GR_GDIOBJECTS);
-    *peak = GetGuiResources(process_with_query_rights, GR_GDIOBJECTS_PEAK);
-    CloseHandle(process_with_query_rights);
-  }
-}
-
-void GetWinUSERHandles(base::ProcessHandle process,
-                       size_t* current,
-                       size_t* peak) {
-  *current = 0;
-  *peak = 0;
-  // Get a handle to |process| that has PROCESS_QUERY_INFORMATION rights.
-  HANDLE current_process = GetCurrentProcess();
-  HANDLE process_with_query_rights;
-  if (DuplicateHandle(current_process, process, current_process,
-                      &process_with_query_rights, PROCESS_QUERY_INFORMATION,
-                      false, 0)) {
-    *current = GetGuiResources(process_with_query_rights, GR_USEROBJECTS);
-    *peak = GetGuiResources(process_with_query_rights, GR_USEROBJECTS_PEAK);
-    CloseHandle(process_with_query_rights);
-  }
-}
-#endif
-
 }  // namespace
 
 class TaskManagerModelGpuDataManagerObserver
     : public content::GpuDataManagerObserver {
  public:
   TaskManagerModelGpuDataManagerObserver() {
     content::GpuDataManager::GetInstance()->AddObserver(this);
   }
 
   ~TaskManagerModelGpuDataManagerObserver() override {
@@ skipping 92 matching lines @@
       task_manager, std::unique_ptr<WebContentsInformation>(
                         new task_manager::PanelInformation())));
   AddResourceProvider(
       new task_manager::ChildProcessResourceProvider(task_manager));
   AddResourceProvider(new task_manager::WebContentsResourceProvider(
       task_manager, std::unique_ptr<WebContentsInformation>(
                         new task_manager::ExtensionInformation())));
   AddResourceProvider(new task_manager::WebContentsResourceProvider(
       task_manager, std::unique_ptr<WebContentsInformation>(
                         new task_manager::GuestInformation())));
-#if defined(OS_WIN)
-  working_set_snapshot_.reset(new PrivateWorkingSetSnapshot);
-  working_set_snapshot_->AddToMonitorList("chrome");
-  working_set_snapshot_->AddToMonitorList("nacl64");
-#endif
 }
 
 void TaskManagerModel::AddObserver(TaskManagerModelObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void TaskManagerModel::RemoveObserver(TaskManagerModelObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
@@ skipping 143 matching lines @@
     return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   if (net_usage == 0)
     return base::ASCIIToUTF16("0");
   base::string16 net_byte = ui::FormatSpeed(net_usage);
   // Force number string to have LTR directionality.
   return base::i18n::GetDisplayStringInLTRDirectionality(net_byte);
 }
 
 base::string16 TaskManagerModel::GetResourceCPUUsage(int index) const {
   return base::UTF8ToUTF16(base::StringPrintf(
-#if defined(OS_MACOSX)
       // Activity Monitor shows %cpu with one decimal digit -- be
       // consistent with that.
       "%.1f",
-#else
-      "%.0f",
-#endif
       GetCPUUsage(GetResource(index))));
 }
 
 base::string16 TaskManagerModel::GetResourcePrivateMemory(int index) const {
   size_t private_mem;
   if (!GetPrivateMemory(index, &private_mem))
     return base::ASCIIToUTF16("N/A");
   return GetMemCellText(private_mem);
 }
 
@@ skipping 113 matching lines @@
   PerProcessValues& values(per_process_cache_[handle]);
 
   if (!values.is_physical_memory_valid) {
     base::WorkingSetKBytes ws_usage;
     MetricsMap::const_iterator iter = metrics_map_.find(handle);
     if (iter == metrics_map_.end() ||
         !iter->second->GetWorkingSetKBytes(&ws_usage))
       return false;
 
     values.is_physical_memory_valid = true;
-#if defined(OS_LINUX)
-    // On Linux private memory is also resident. Just use it.
-    values.physical_memory = ws_usage.priv * 1024;
-#else
     // Memory = working_set.private which is working set minus shareable. This
     // avoids the unpredictable counting that occurs when calculating memory as
     // working set minus shared (renderer code counted when one tab is open and
     // not counted when two or more are open) and it is much more efficient to
     // calculate on Windows.
     values.physical_memory = iter->second->GetWorkingSetSize();
     values.physical_memory -= ws_usage.shareable * 1024;
-#endif
   }
   *result = values.physical_memory;
   return true;
 }
 
 void TaskManagerModel::GetGDIHandles(int index,
                                      size_t* current,
                                      size_t* peak) const {
   *current = 0;
   *peak = 0;
-#if defined(OS_WIN)
-  base::ProcessHandle handle = GetResource(index)->GetProcess();
-  PerProcessValues& values(per_process_cache_[handle]);
-
-  if (!values.is_gdi_handles_valid) {
-    GetWinGDIHandles(GetResource(index)->GetProcess(),
-                     &values.gdi_handles,
-                     &values.gdi_handles_peak);
-    values.is_gdi_handles_valid = true;
-  }
-  *current = values.gdi_handles;
-  *peak = values.gdi_handles_peak;
-#endif
 }
 
 void TaskManagerModel::GetUSERHandles(int index,
                                       size_t* current,
                                       size_t* peak) const {
   *current = 0;
   *peak = 0;
-#if defined(OS_WIN)
-  base::ProcessHandle handle = GetResource(index)->GetProcess();
-  PerProcessValues& values(per_process_cache_[handle]);
-
-  if (!values.is_user_handles_valid) {
-    GetWinUSERHandles(GetResource(index)->GetProcess(),
-                      &values.user_handles,
-                      &values.user_handles_peak);
-    values.is_user_handles_valid = true;
-  }
-  *current = values.user_handles;
-  *peak = values.user_handles_peak;
-#endif
 }
 
 bool TaskManagerModel::GetWebCoreCacheStats(
     int index,
     blink::WebCache::ResourceTypeStats* result) const {
   if (!CacheWebCoreStats(index))
     return false;
   *result = GetPerResourceValues(index).webcore_stats;
   return true;
 }
@@ skipping 301 matching lines @@
         std::find(resources_.begin(),
                   resources_.end(),
                   (*group_entries)[group_entries->size() - 2]);
     DCHECK(iter != resources_.end());
     new_entry_index = static_cast<int>(iter - resources_.begin()) + 1;
     resources_.insert(++iter, resource);
   }
 
   // Create the ProcessMetrics for this process if needed (not in map).
   if (metrics_map_.find(process) == metrics_map_.end()) {
-    base::ProcessMetrics* pm =
-#if !defined(OS_MACOSX)
-        base::ProcessMetrics::CreateProcessMetrics(process);
-#else
+    std::unique_ptr<base::ProcessMetrics> pm =
         base::ProcessMetrics::CreateProcessMetrics(
             process, content::BrowserChildProcessHost::GetPortProvider());
-#endif
-
-    metrics_map_[process] = pm;
+    metrics_map_[process] = pm.release();
   }
 
   // Notify the table that the contents have changed for it to redraw.
   FOR_EACH_OBSERVER(TaskManagerModelObserver, observer_list_,
                     OnItemsAdded(new_entry_index, 1));
 }
 
 void TaskManagerModel::RemoveResource(Resource* resource) {
   base::ProcessHandle process = resource->GetProcess();
 
@@ skipping 151 matching lines @@
                       OnItemsRemoved(0, size));
   }
 }
 
 void TaskManagerModel::ModelChanged() {
   // Notify the table that the contents have changed for it to redraw.
   FOR_EACH_OBSERVER(TaskManagerModelObserver, observer_list_, OnModelChanged());
 }
 
 void TaskManagerModel::RefreshPhysicalMemoryFromWorkingSetSnapshot() {
-#if defined(OS_WIN)
-  // Collect working-set data for all monitored processes in one operation, to
-  // avoid the inefficiency of retrieving it one at a time.
-  working_set_snapshot_->Sample();
-
-  for (size_t i = 0; i < resources_.size(); ++i) {
-    size_t private_working_set =
-        working_set_snapshot_->GetPrivateWorkingSet(GetProcessId(i));
-
-    // If working-set data is available then use it. If not then
-    // GetWorkingSetKBytes will retrieve the data. This is rare except on
-    // Windows XP where GetWorkingSetKBytes will always be used.
-    if (private_working_set) {
-      // Fill in the cache with the retrieved private working set value.
-      base::ProcessHandle handle = GetResource(i)->GetProcess();
-      PerProcessValues& values(per_process_cache_[handle]);
-      values.is_physical_memory_valid = true;
-      // Note that the other memory fields are *not* filled in.
-      values.physical_memory = private_working_set;
-    }
-  }
-#else
 // This is a NOP on other platforms because they can efficiently retrieve
 // the private working-set data on a per-process basis.
-#endif
 }
 
 void TaskManagerModel::Refresh() {
   per_resource_cache_.clear();
   per_process_cache_.clear();
   RefreshPhysicalMemoryFromWorkingSetSnapshot();
 
 #if !defined(DISABLE_NACL)
   nacl::NaClBrowser* nacl_browser = nacl::NaClBrowser::GetInstance();
 #endif  // !defined(DISABLE_NACL)
@@ skipping 20 matching lines @@
     }
 #endif  // !defined(DISABLE_NACL)
     if (values.is_cpu_usage_valid && values.is_idle_wakeups_valid)
       continue;
     MetricsMap::iterator metrics_iter = metrics_map_.find(process);
     DCHECK(metrics_iter != metrics_map_.end());
     if (!values.is_cpu_usage_valid) {
       values.is_cpu_usage_valid = true;
       values.cpu_usage = metrics_iter->second->GetCPUUsage();
     }
-#if defined(OS_MACOSX) || defined(OS_LINUX)
     // TODO(port): Implement GetIdleWakeupsPerSecond() on other platforms,
     // crbug.com/120488
     if (!values.is_idle_wakeups_valid) {
       values.is_idle_wakeups_valid = true;
       values.idle_wakeups = metrics_iter->second->GetIdleWakeupsPerSecond();
     }
-#endif  // defined(OS_MACOSX) || defined(OS_LINUX)
   }
 
   // Send a request to refresh GPU memory consumption values
   RefreshVideoMemoryUsageStats();
 
   // Compute the new network usage values.
   base::TimeDelta update_time =
       base::TimeDelta::FromMilliseconds(kUpdateTimeMs);
   for (ResourceValueMap::iterator iter = current_byte_count_map_.begin();
        iter != current_byte_count_map_.end(); ++iter) {
@@ skipping 196 matching lines @@
   return values.cpu_usage;
 }
 
 int TaskManagerModel::GetIdleWakeupsPerSecond(Resource* resource) const {
   const PerProcessValues& values(per_process_cache_[resource->GetProcess()]);
   // Returns 0 if not valid, which is fine.
   return values.idle_wakeups;
 }
 
 base::string16 TaskManagerModel::GetMemCellText(int64_t number) const {
-#if !defined(OS_MACOSX)
-  base::string16 str = base::FormatNumber(number / 1024);
-
-  // Adjust number string if necessary.
-  base::i18n::AdjustStringForLocaleDirection(&str);
-  return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_MEM_CELL_TEXT, str);
-#else
   // System expectation is to show "100 kB", "200 MB", etc.
   // TODO(thakis): Switch to metric units (as opposed to powers of two).
   return ui::FormatBytes(number);
-#endif
 }
 
 bool TaskManagerModel::CachePrivateAndSharedMemory(
     base::ProcessHandle handle) const {
   PerProcessValues& values(per_process_cache_[handle]);
   if (values.is_private_and_shared_valid)
     return true;
 
   MetricsMap::const_iterator iter = metrics_map_.find(handle);
   if (iter == metrics_map_.end() ||
@@ skipping 97 matching lines @@
   CHECK(!task_management::TaskManagerInterface::IsNewTaskManagerEnabled());
   return base::Singleton<TaskManager>::get();
 }
 
 TaskManager::TaskManager()
     : model_(new TaskManagerModel(this)) {
 }
 
 TaskManager::~TaskManager() {
 }