Migrate ProcessesEventRouter to the new task manager

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 "base/bind.h"
 #include "base/callback.h"
 #include "base/stl_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/task_management/task_manager_observer.h"
 #include "components/nacl/browser/nacl_browser.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace task_management {
 
 namespace {
 
+// A mask for the refresh types that are done in the background thread.
+const int kBackgroundRefreshTypesMask =
+    REFRESH_TYPE_CPU |
+    REFRESH_TYPE_MEMORY |
+    REFRESH_TYPE_IDLE_WAKEUPS |
+#if defined(OS_LINUX)
+    REFRESH_TYPE_FD_COUNT |
+#endif  // defined(OS_LINUX)
+    REFRESH_TYPE_PRIORITY;
+
 inline bool IsResourceRefreshEnabled(RefreshType refresh_type,
                                      int refresh_flags) {
   return (refresh_flags & refresh_type) != 0;
 }
 
 #if defined(OS_WIN)
 // Gets the GDI and USER Handles on Windows at one shot.
 void GetWindowsHandles(base::ProcessHandle handle,
                        int64_t* out_gdi_current,
                        int64_t* out_gdi_peak,
@@ skipping 20 matching lines @@
     CloseHandle(process_with_query_rights);
   }
 }
 #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<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),
-      tasks_(),
+      expected_on_bg_done_flags_(kBackgroundRefreshTypesMask),
+      current_on_bg_done_flags_(0),
       cpu_usage_(0.0),
       memory_usage_(),
       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),
 #endif  // defined(OS_WIN)
@@ skipping 42 matching lines @@
 
   tasks_.erase(task->task_id());
 }
 
 void TaskGroup::Refresh(
     const content::GPUVideoMemoryUsageStats& gpu_memory_stats,
     base::TimeDelta update_interval,
     int64_t refresh_flags) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
+  expected_on_bg_done_flags_ = refresh_flags & kBackgroundRefreshTypesMask;

[ncarter (slow), 2016/02/17 21:21:19]

Is it possible for the next Refresh event to fire, before we hear back from the
blocking pool for the previous refresh? Does anything weird happen if it does?

[afakhry, 2016/02/19 17:35:09]

I think it could, since we are using a sequenced task runner for the background
thread. So, I think if we have a lot a lot of tasks, with a lot of background
refresh types enabled, it could happen that (at a one-second refresh interval)
the periodic Refresh() happens before all background operations finishes.

There shouldn't be anything weird if that happens. We only fire the event
TaskManagerObserver::OnTasksRefreshedWithBackgroundCalculations() when all
TaskGroups have heard back from their background samplers for all the enabled
refresh types.

We clear |current_on_bg_done_flags_| only when all observers have been notified
with OnTasksRefreshedWithBackgroundCalculations() at which point we are ready
for another cycle for this event.

So This event means we have ready data for the background calculations like the
CPU or memory ***from the most recent completed background operation***. That
could be from an operation triggered by the current Refresh() or the previous
one. The thing is once we have a complete snapshot of all background data, we
broadcast this event, reset |current_on_bg_done_flags_|, repeat.

[ncarter (slow), 2016/02/19 18:19:03]

OK.

I do worry a bit about the case where sampling takes longer than 1s on average
(due e.g. to extreme load), and we wind up with a queue of Refresh() tasks that
grows faster than it drains.

+
   // First refresh the enabled non-expensive resources usages on the UI thread.
   // 1- Refresh all the tasks as well as the total network usage (if enabled).
   const bool network_usage_refresh_enabled =
       IsResourceRefreshEnabled(REFRESH_TYPE_NETWORK_USAGE, refresh_flags);
   per_process_network_usage_ = network_usage_refresh_enabled ? 0 : -1;
   for (auto& task_pair : tasks_) {
     Task* task = task_pair.second;
     task->Refresh(update_interval, refresh_flags);
 
-    if (network_usage_refresh_enabled && task->ReportsNetworkUsage()) {
+    if (network_usage_refresh_enabled && task->ReportsNetworkUsage())
       per_process_network_usage_ += task->network_usage();
-    }
   }
 
   // 2- Refresh GPU memory (if enabled).
   if (IsResourceRefreshEnabled(REFRESH_TYPE_GPU_MEMORY, refresh_flags))
     RefreshGpuMemory(gpu_memory_stats);
 
   // 3- Refresh Windows handles (if enabled).
 #if defined(OS_WIN)
   if (IsResourceRefreshEnabled(REFRESH_TYPE_HANDLES, refresh_flags))
     RefreshWindowsHandles();
@@ skipping 59 matching lines @@
   nacl::NaClBrowser* nacl_browser = nacl::NaClBrowser::GetInstance();
   nacl_debug_stub_port_ =
       nacl_browser->GetProcessGdbDebugStubPort(child_process_unique_id);
 #endif // !defined(DISABLE_NACL)
 }
 
 void TaskGroup::OnCpuRefreshDone(double cpu_usage) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   cpu_usage_ = cpu_usage;
+  OnBackgroundRefreshTypeFinished(REFRESH_TYPE_CPU);
 }
 
 void TaskGroup::OnMemoryUsageRefreshDone(MemoryUsageStats memory_usage) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   memory_usage_ = memory_usage;
+  OnBackgroundRefreshTypeFinished(REFRESH_TYPE_MEMORY);
 }
 
 void TaskGroup::OnIdleWakeupsRefreshDone(int idle_wakeups_per_second) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   idle_wakeups_per_second_ = idle_wakeups_per_second;
+  OnBackgroundRefreshTypeFinished(REFRESH_TYPE_IDLE_WAKEUPS);
 }
 
 #if defined(OS_LINUX)
 void TaskGroup::OnOpenFdCountRefreshDone(int open_fd_count) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   open_fd_count_ = open_fd_count;
+  OnBackgroundRefreshTypeFinished(REFRESH_TYPE_FD_COUNT);
 }
 #endif  // defined(OS_LINUX)
 
 void TaskGroup::OnProcessPriorityDone(bool is_backgrounded) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   is_backgrounded_ = is_backgrounded;
+  OnBackgroundRefreshTypeFinished(REFRESH_TYPE_PRIORITY);
+}
+
+void TaskGroup::OnBackgroundRefreshTypeFinished(int64_t finished_refresh_type) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  current_on_bg_done_flags_ |= finished_refresh_type;

[ncarter (slow), 2016/02/17 21:21:19]

current_on_bg_done_flags_ is never cleared back to 0. Is that intentional?

Since the TaskGroup can persist across extension function invocations, it seems
like subsequent queries might notify too early, when the first (rather than
last) background type reports back "refresh done", and I imagine that the other
types would be stale at this point?

[afakhry, 2016/02/19 17:35:09]

Oh sorry it was clear enough. |current_on_bg_done_flags_| is actually cleared in
the ClearCurrentBackgroundCalculationsFlags() in task_group.h. I moved the
definition to the .cc file.

+  if (current_on_bg_done_flags_ == expected_on_bg_done_flags_)

[ncarter (slow), 2016/02/17 21:21:19]

What if refresh_flags (at Refresh() time) didn't specify *all* of the
kBackgroundRefreshTypesMask types? In that case it seems like we'll never run
the callback (because e.g. OnIdleWakeupsRefreshDone won't happen if
REFRESH_TYPE_IDLE_WAKEUPS wasn't requested?)

[afakhry, 2016/02/19 17:35:09]

Thanks! I added a line to TaskGroup:Refresh() to take care of this case when a
refresh type gets disabled.

+    on_background_calculations_done_.Run();
 }
 
 }  // namespace task_management