Task manager should support Idle Wakeups on Windows

chrome/browser/task_management/sampling/task_group.cc

 // Copyright 2015 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_management/sampling/task_group.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/stl_util.h"
 #include "build/build_config.h"
+#include "chrome/browser/task_management/sampling/shared_sampler.h"
 #include "chrome/browser/task_management/task_manager_observer.h"
 #include "components/nacl/browser/nacl_browser.h"
 #include "content/public/browser/browser_thread.h"
 #include "gpu/ipc/common/memory_stats.h"
 
 namespace task_management {
 
 namespace {
 
 // A mask for the refresh types that are done in the background thread.
@@ skipping 35 matching lines @@
   }
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace
 
 TaskGroup::TaskGroup(
     base::ProcessHandle proc_handle,
     base::ProcessId proc_id,
     const base::Closure& on_background_calculations_done,
+    const scoped_refptr<SharedSampler> shared_sampler,

[ncarter (slow), 2016/07/28 21:37:27]

Passing like this will cause an extra increment/decrement of the refcount.

You can eliminate that either by:

 - pass this as a const ref
 - pass as a non-const value, and std::move() it into shared_sampler_

[stanisc, 2016/07/28 22:38:44]

Yeah, I meant a const ref here, but omitted '&' by mistake.

[stanisc, 2016/08/01 22:34:27]

Done.

     const scoped_refptr<base::SequencedTaskRunner>& blocking_pool_runner)
     : process_handle_(proc_handle),
       process_id_(proc_id),
       on_background_calculations_done_(on_background_calculations_done),
       worker_thread_sampler_(nullptr),
+      shared_sampler_(shared_sampler),
       expected_on_bg_done_flags_(kBackgroundRefreshTypesMask),
       current_on_bg_done_flags_(0),
       cpu_usage_(0.0),
       gpu_memory_(-1),
       per_process_network_usage_(-1),
 #if defined(OS_WIN)
       gdi_current_handles_(-1),
       gdi_peak_handles_(-1),
       user_current_handles_(-1),
       user_peak_handles_(-1),
@@ skipping 17 matching lines @@
                                       weak_ptr_factory_.GetWeakPtr()),
                            base::Bind(&TaskGroup::OnIdleWakeupsRefreshDone,
                                       weak_ptr_factory_.GetWeakPtr()),
 #if defined(OS_LINUX)
                            base::Bind(&TaskGroup::OnOpenFdCountRefreshDone,
                                       weak_ptr_factory_.GetWeakPtr()),
 #endif  // defined(OS_LINUX)
                            base::Bind(&TaskGroup::OnProcessPriorityDone,
                                       weak_ptr_factory_.GetWeakPtr())));
   worker_thread_sampler_.swap(sampler);
+
+  shared_sampler_->RegisterCallbacks(
+      process_id_, base::Bind(&TaskGroup::OnIdleWakeupsRefreshDone,
+                              weak_ptr_factory_.GetWeakPtr()));
 }
 
 TaskGroup::~TaskGroup() {
+  shared_sampler_->UnregisterCallbacks(process_id_);
 }
 
 void TaskGroup::AddTask(Task* task) {
   DCHECK(task);
   tasks_.push_back(task);
 }
 
 void TaskGroup::RemoveTask(Task* task) {
   DCHECK(task);
   tasks_.erase(std::remove(tasks_.begin(), tasks_.end(), task), tasks_.end());
@@ skipping 37 matching lines @@
 
   // 4- Refresh the NACL debug stub port (if enabled).
 #if !defined(DISABLE_NACL)
   if (TaskManagerObserver::IsResourceRefreshEnabled(REFRESH_TYPE_NACL,
                                                     refresh_flags) &&
       !tasks_.empty()) {
     RefreshNaClDebugStubPort(tasks_[0]->GetChildProcessUniqueID());
   }
 #endif  // !defined(DISABLE_NACL)
 
+  int64_t shared_refresh_flags =
+      refresh_flags & shared_sampler_->SupportsFlags();
+
+  // 5- Refresh resources via SharedSampler if the current platform
+  // implementation supports that. The actual work is done on the worker thread.
+  // At the moment this is supported only on OS_WIN.
+  if (shared_refresh_flags != 0) {
+    shared_sampler_->Refresh(process_id_, shared_refresh_flags);
+    refresh_flags &= ~shared_refresh_flags;
+  }
+
   // The remaining resource refreshes are time consuming and cannot be done on
   // the UI thread. Do them all on the worker thread using the TaskGroupSampler.
-  // 5- CPU usage.
-  // 6- Memory usage.
-  // 7- Idle Wakeups per second.
-  // 8- (Linux and ChromeOS only) The number of file descriptors current open.
-  // 9- Process priority (foreground vs. background).
+  // 6-  CPU usage.
+  // 7-  Memory usage.
+  // 8-  Idle Wakeups per second.
+  // 9-  (Linux and ChromeOS only) The number of file descriptors current open.
+  // 10- Process priority (foreground vs. background).
   worker_thread_sampler_->Refresh(refresh_flags);
 }
 
 Task* TaskGroup::GetTaskById(TaskId task_id) const {
   for (Task* task : tasks_) {
     if (task->task_id() == task_id)
       return task;
   }
   NOTREACHED();
   return nullptr;
@@ skipping 77 matching lines @@
 
 void TaskGroup::OnBackgroundRefreshTypeFinished(int64_t finished_refresh_type) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   current_on_bg_done_flags_ |= finished_refresh_type;
   if (AreBackgroundCalculationsDone())
     on_background_calculations_done_.Run();
 }
 
 }  // namespace task_management