NOCOMMIT PROTOTYPE [GRC] Tab CPU Usage Observer

NOCOMMIT PROTOTYPE [GRC] Tab CPU Usage Observer

This is a CoordinationUnitGraphObserver implementation that performs tab-level CPU usage attribution.

Each process is given a namespace via a ProcessObserver class which
itself holds onto a collection of TabObserver class instances that
correspond to the tabs that are contained within it.

Currently the implementation makes some naive assumptions:
- Process CPU is evenly attributable among the tabs within it.
  For example, if a process with two CPU tabs has 50% utilization then
  each tab is attributed with 25%.
- Any parentless-frame is assumed to correspond to a tab. In reality
  a tab (e.g. WebContents) can have have multiple parentless-frames
  because multiple navigations can exist within a single instance.

R=*oysteine@chromium.org,*zhenw@chromium.org,lpy@google.com,fmeawad@chromium.org
BUG=724306

[matthalp, 2017-06-07 21:57:39]

matthalp@google.com changed reviewers:
+ lpy@google.com, zhenw@chromium.org

[matthalp, 2017-06-07 21:58:09]

Adding reviewers

[matthalp, 2017-06-12 20:53:56]

Description was changed from

==========
NOCOMMIT PROTOTYPE [GRC] Tab CPU Usage Observer

This is a prototype Tab CPU Usage Observer for GRC. It collects
process-level CPU usage information and attributes it to the tabs
that currently exist within the process.

Each process is given a namespace via a ProcessObserver class which
itself holds onto a collection of TabObserver class instances that
correspond to the tabs that are contained within it.

Currently the implementation makes some naive assumptions:
- Process CPU is evently attributable amongst the tabs within it.
  For example, if a process with two CPU tabs has 50% utilization then
  each tab is attributed with 25%.
- Any parentless-frame is assumed to correspond to a tab. In reality
  a tab (e.g. WebContents) can have have multiple parentless-frames
  because multiple navigations can exist within a single instance.

R=oysteine@chromium.org
BUG=724306
==========

to

==========
NOCOMMIT PROTOTYPE [GRC] Tab CPU Usage Observer

This is a CoordinationUnitGraphObserver implementation that performs tab-level
CPU usage attribution.

Each process is given a namespace via a ProcessObserver class which
itself holds onto a collection of TabObserver class instances that
correspond to the tabs that are contained within it.

Currently the implementation makes some naive assumptions:
- Process CPU is evenly attributable among the tabs within it.
  For example, if a process with two CPU tabs has 50% utilization then
  each tab is attributed with 25%.
- Any parentless-frame is assumed to correspond to a tab. In reality
  a tab (e.g. WebContents) can have have multiple parentless-frames
  because multiple navigations can exist within a single instance.

R=oysteine@chromium.org,zhenw@chromium.org,lpy@google.com
BUG=724306
==========

[matthalp, 2017-06-12 20:53:56]

matthalp@google.com changed required reviewers:
+ oysteine@chromium.org, zhenw@chromium.org

[matthalp, 2017-06-15 17:02:14]

Description was changed from

==========
NOCOMMIT PROTOTYPE [GRC] Tab CPU Usage Observer

This is a CoordinationUnitGraphObserver implementation that performs tab-level
CPU usage attribution.

Each process is given a namespace via a ProcessObserver class which
itself holds onto a collection of TabObserver class instances that
correspond to the tabs that are contained within it.

Currently the implementation makes some naive assumptions:
- Process CPU is evenly attributable among the tabs within it.
  For example, if a process with two CPU tabs has 50% utilization then
  each tab is attributed with 25%.
- Any parentless-frame is assumed to correspond to a tab. In reality
  a tab (e.g. WebContents) can have have multiple parentless-frames
  because multiple navigations can exist within a single instance.

R=oysteine@chromium.org,zhenw@chromium.org,lpy@google.com
BUG=724306
==========

to

==========
NOCOMMIT PROTOTYPE [GRC] Tab CPU Usage Observer

This is a CoordinationUnitGraphObserver implementation that performs tab-level
CPU usage attribution.

Each process is given a namespace via a ProcessObserver class which
itself holds onto a collection of TabObserver class instances that
correspond to the tabs that are contained within it.

Currently the implementation makes some naive assumptions:
- Process CPU is evenly attributable among the tabs within it.
  For example, if a process with two CPU tabs has 50% utilization then
  each tab is attributed with 25%.
- Any parentless-frame is assumed to correspond to a tab. In reality
  a tab (e.g. WebContents) can have have multiple parentless-frames
  because multiple navigations can exist within a single instance.

R=*oysteine@chromium.org,*zhenw@chromium.org,lpy@google.com,fmeawad@chromium.org
BUG=724306
==========

[matthalp, 2017-06-15 17:02:14]

matthalp@google.com changed reviewers:
+ fmeawad@chromium.org

[lpy, 2017-06-16 22:43:53]

Description was changed from

==========
NOCOMMIT PROTOTYPE [GRC] Tab CPU Usage Observer

This is a CoordinationUnitGraphObserver implementation that performs tab-level
CPU usage attribution.

Each process is given a namespace via a ProcessObserver class which
itself holds onto a collection of TabObserver class instances that
correspond to the tabs that are contained within it.

Currently the implementation makes some naive assumptions:
- Process CPU is evenly attributable among the tabs within it.
  For example, if a process with two CPU tabs has 50% utilization then
  each tab is attributed with 25%.
- Any parentless-frame is assumed to correspond to a tab. In reality
  a tab (e.g. WebContents) can have have multiple parentless-frames
  because multiple navigations can exist within a single instance.

R=*oysteine@chromium.org,*zhenw@chromium.org,lpy@google.com,fmeawad@chromium.org
BUG=724306
==========

to

==========
NOCOMMIT PROTOTYPE [GRC] Tab CPU Usage Observer

This is a CoordinationUnitGraphObserver implementation that performs tab-level
CPU usage attribution.

Each process is given a namespace via a ProcessObserver class which
itself holds onto a collection of TabObserver class instances that
correspond to the tabs that are contained within it.

Currently the implementation makes some naive assumptions:
- Process CPU is evenly attributable among the tabs within it.
  For example, if a process with two CPU tabs has 50% utilization then
  each tab is attributed with 25%.
- Any parentless-frame is assumed to correspond to a tab. In reality
  a tab (e.g. WebContents) can have have multiple parentless-frames
  because multiple navigations can exist within a single instance.

R=*oysteine@chromium.org,*zhenw@chromium.org,lpy@google.com,fmeawad@chromium.org
BUG=724306
==========

[lpy, 2017-06-16 22:43:53]

lpy@chromium.org changed reviewers:
+ lpy@chromium.org
- lpy@google.com

[Zhen Wang, 2017-06-16 22:47:45]

https://codereview.chromium.org/2925123002/diff/180001/services/resource_coor...
File services/resource_coordinator/coordination_unit/tab_cpu_usage_observer.cc
(right):

https://codereview.chromium.org/2925123002/diff/180001/services/resource_coor...
services/resource_coordinator/coordination_unit/tab_cpu_usage_observer.cc:153:
mojom::PropertyType::kProcessCPUUsage);
I see your point here that one may want to listen to multiple property types (or
CU types for other listeners).

But I think you can get this done similarly with the typical observer pattern. I
admit that you need one more switch to dispatch the 2 property types.


void TabCPUUsageObserver::TabCoordinationUnitCreated(tab_coordination_unit) {
  DCHECK(!tab_observers_.count(tab_coordination_unit->id()));
  auto& tab_observer = tab_observers_[tab_coordination_unit->id()];
  tab_observer.SetTabCPUUsageObserver(this);

  cu->ObservePropertyChangeEvent(this, mojom::PropertyType::kTabURL);
  // And other ones...
}

void
TabCPUUsageObserver::ProcessCoordinationUnitCreated(process_coordination_unit) {
  DCHECK(!process_observers_.count(process_coordination_unit->id()));
  ProcessObserver& process_observer =
      process_observers_[process_coordination_unit->id()];
  process_observer.SetTabCPUUsageObserver(this);

  cu->ObservePropertyChangeEvent(this, mojom::PropertyType::kProcessCPUUsage);
  // And other ones...
}

// This is the new API replacing the callback way.
TabCPUUsageObserver::OnPropertyChanged(cu, property) {
  switch (property.type) {
    case mojom::PropertyType::kTabURL:
      GetTabObserver(cu)->TabURLChanged(cu, property);
    case mojom::PropertyType::kProcessCPUUsage:
      GetProcessObserver(cu)->NewCPUUsageMeasurement(cu, property);
    default:
      DCHECK(false); // should never happen
  }
}

TabCPUUsageObserver::GetTabObserver(cu) {
  // can be implemented with a map
}

TabCPUUsageObserver::GetTabObserver(cu) {
  // can be implemented with a map
}