Global Resource Coordinator: Basic service internals

services/resource_coordinator/coordination_unit/coordination_unit_impl.cc

+// Copyright 2017 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 "services/resource_coordinator/coordination_unit/coordination_unit_impl.h"
+
+#include "base/hash.h"
+#include "base/lazy_instance.h"

[Primiano Tucci (use gerrit), 2017/04/11 18:04:51]

I think you don't need this anymore

[oystein (OOO til 10th of July), 2017/04/12 19:15:31]

Done.

+#include "base/logging.h"
+#include "base/strings/string_number_conversions.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "services/resource_coordinator/public/cpp/coordination_unit_events.h"
+#include "services/resource_coordinator/public/cpp/coordination_unit_id.h"
+#include "services/service_manager/public/cpp/connection.h"
+
+namespace resource_coordinator {
+
+namespace {
+
+using CUIDMap = std::unordered_map<CoordinationUnitID, CoordinationUnitImpl*>;
+
+CUIDMap* g_cu_map() {
+  static CUIDMap* instance = new CUIDMap();
+  return instance;
+}
+
+}  // namespace
+
+CoordinationUnitImpl::CoordinationUnitImpl(
+    const CoordinationUnitID& id,
+    std::unique_ptr<service_manager::ServiceContextRef> service_ref)
+    : id_(id) {
+  auto it = g_cu_map()->insert(std::make_pair(id_, this));
+  DCHECK(it.second); /* did insert */

[Primiano Tucci (use gerrit), 2017/04/11 18:04:51]

micro nit: /* -> // , I usually see this for single line comments 

[oystein (OOO til 10th of July), 2017/04/12 19:15:31]

Done.

+
+  service_ref_ = std::move(service_ref);
+}
+
+CoordinationUnitImpl::~CoordinationUnitImpl() {
+  g_cu_map()->erase(id_);
+
+  for (auto* child : children_) {

[Primiano Tucci (use gerrit), 2017/04/11 18:04:51]

not very strong on this, but usually I find the full type (i.e.
s/auto*/CoordinationUnitImpl*/) easier to read, as long as it says in one line
(read: I use auto only if the full type wouldn't fit in 80 cols). But we don't
have a rule for this, so this is fine as well

[oystein (OOO til 10th of July), 2017/04/12 19:15:31]

Done.

+    child->RemoveParent(this);
+  }
+
+  for (auto* parent : parents_) {
+    parent->RemoveChild(this);
+  }
+}
+
+bool CoordinationUnitImpl::SelfOrParentHasFlagSet(StateFlags state) {
+  const base::Optional<bool>& state_flag = state_flags_[state];
+  if (state_flag && *state_flag)
+    return true;
+
+  for (auto* parent : parents_) {
+    if (parent->SelfOrParentHasFlagSet(state))
+      return true;
+  }
+
+  return false;
+}
+
+void CoordinationUnitImpl::RecalcPolicy() {
+  for (auto* child : children_) {
+    child->RecalcPolicy();
+  }
+
+  if (!policy_callback_) {
+    return;
+  }
+
+  bool background_priority = !SelfOrParentHasFlagSet(TAB_VISIBLE) &&
+                             !SelfOrParentHasFlagSet(AUDIO_PLAYING);
+
+  // Send the priority to the client if it's new or changed.
+  if (!current_policy_)
+    current_policy_ = mojom::Policy::New();
+  else if ((current_policy_->use_background_priority == background_priority) &&
+           !SelfOrParentHasFlagSet(StateFlags::TEST_STATE)) {
+    return;
+  }
+
+  mojom::PolicyPtr policy = mojom::Policy::New();
+  policy->use_background_priority = background_priority;
+  current_policy_->use_background_priority = background_priority;
+
+  policy_callback_->SetPolicy(std::move(policy));
+}
+
+void CoordinationUnitImpl::SendEvent(mojom::EventPtr event) {
+  switch (event->type) {
+    case EventType::ON_WEBCONTENTS_SHOWN:
+      state_flags_[TAB_VISIBLE] = true;
+      break;
+    case EventType::ON_WEBCONTENTS_HIDDEN:
+      state_flags_[TAB_VISIBLE] = false;
+      break;
+    case EventType::ON_PROCESS_AUDIO_STARTED:
+      state_flags_[AUDIO_PLAYING] = true;
+      break;
+    case EventType::ON_PROCESS_AUDIO_STOPPED:
+      state_flags_[AUDIO_PLAYING] = false;
+      break;
+    case EventType::TEST_EVENT:
+      state_flags_[TEST_STATE] = true;
+      break;
+    default:
+      return;
+  }
+
+  RecalcPolicy();
+}
+
+void CoordinationUnitImpl::GetID(const GetIDCallback& callback) {
+  callback.Run(id_);
+}
+
+void CoordinationUnitImpl::Duplicate(mojom::CoordinationUnitRequest request) {
+  bindings_.AddBinding(this, std::move(request));
+}
+
+void CoordinationUnitImpl::AddChild(const CoordinationUnitID& child_id) {
+  if (child_id == id_)
+    return;
+
+  auto child_iter = g_cu_map()->find(child_id);
+  if (child_iter != g_cu_map()->end()) {
+    CoordinationUnitImpl* child = child_iter->second;
+    if (HasParent(child) || HasChild(child))
+      return;
+
+    DCHECK(child->id_ == child_id);
+    DCHECK(child != this);
+
+    if (AddChild(child)) {
+      child->AddParent(this);
+    }
+  }
+}
+
+bool CoordinationUnitImpl::AddChild(CoordinationUnitImpl* child) {
+  return children_.count(child) ? false : children_.insert(child).second;
+}
+
+void CoordinationUnitImpl::RemoveChild(CoordinationUnitImpl* child) {
+  size_t children_removed = children_.erase(child);
+  DCHECK_EQ(1u, children_removed);
+}
+
+void CoordinationUnitImpl::AddParent(CoordinationUnitImpl* parent) {
+  DCHECK(parents_.find(parent) == parents_.end());

[Primiano Tucci (use gerrit), 2017/04/11 18:04:51]

maybe just use .count() for uniformity with ::AddChild?

[oystein (OOO til 10th of July), 2017/04/12 19:15:31]

Done.

+  parents_.insert(parent);
+
+  RecalcPolicy();
+}
+
+void CoordinationUnitImpl::RemoveParent(CoordinationUnitImpl* parent) {
+  size_t parents_removed = parents_.erase(parent);
+  DCHECK_EQ(1u, parents_removed);
+
+  RecalcPolicy();
+}
+
+bool CoordinationUnitImpl::HasParent(CoordinationUnitImpl* unit) {
+  for (auto* parent : parents_) {
+    if (parent == unit || parent->HasParent(unit))
+      return true;
+  }
+
+  return false;
+}
+
+bool CoordinationUnitImpl::HasChild(CoordinationUnitImpl* unit) {
+  for (auto* child : children_) {
+    if (child == unit || child->HasChild(unit))
+      return true;
+  }
+
+  return false;
+}
+
+void CoordinationUnitImpl::SetPolicyCallback(
+    mojom::PolicyCallbackPtr callback) {
+  callback.set_connection_error_handler(base::Bind(
+      &CoordinationUnitImpl::UnregisterPolicyCallback, base::Unretained(this)));
+
+  policy_callback_ = std::move(callback);
+
+  RecalcPolicy();
+}
+
+void CoordinationUnitImpl::UnregisterPolicyCallback() {
+  policy_callback_.reset();
+  current_policy_.reset();
+}
+
+}  // namespace resource_coordinator