NOCOMMIT prototype: GRC service plumbing and process priority

content/browser/renderer_host/render_process_host_impl.cc

 // Copyright 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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #include <algorithm>
@@ skipping 689 matching lines @@
           id_,
           storage_partition_impl_->GetURLRequestContext(),
           storage_partition_impl_->GetIndexedDBContext(),
           ChromeBlobStorageContext::GetFor(browser_context_))),
       channel_connected_(false),
       sent_render_process_ready_(false),
 #if defined(OS_ANDROID)
       never_signaled_(base::WaitableEvent::ResetPolicy::MANUAL,
                       base::WaitableEvent::InitialState::NOT_SIGNALED),
 #endif
+      resource_coordinator_binding_(this),
       instance_weak_factory_(
           new base::WeakPtrFactory<RenderProcessHostImpl>(this)),
       weak_factory_(this) {
   widget_helper_ = new RenderWidgetHelper();
 
   ChildProcessSecurityPolicyImpl::GetInstance()->Add(GetID());
 
   CHECK(!BrowserMainRunner::ExitedMainMessageLoop());
   RegisterHost(GetID(), this);
   g_all_hosts.Get().set_check_on_null_data(true);
@@ skipping 826 matching lines @@
     base::debug::DumpWithoutCrashing();
   }
 
   // Log the renderer kill to the histogram tracking all kills.
   BrowserChildProcessHostImpl::HistogramBadMessageTerminated(
       PROCESS_TYPE_RENDERER);
 }
 
 void RenderProcessHostImpl::WidgetRestored() {
   visible_widgets_++;
-  UpdateProcessPriority();
+  // UpdateProcessPriority();
   DCHECK(!is_process_backgrounded_);
 }
 
 void RenderProcessHostImpl::WidgetHidden() {
   // On startup, the browser will call Hide. We ignore this call.
   if (visible_widgets_ == 0)
     return;
 
   --visible_widgets_;
   if (visible_widgets_ == 0) {
     DCHECK(!is_process_backgrounded_);
-    UpdateProcessPriority();
+    // UpdateProcessPriority();
   }
 }
 
 int RenderProcessHostImpl::VisibleWidgetCount() const {
   return visible_widgets_;
 }
 
 void RenderProcessHostImpl::OnAudioStreamAdded() {
-  ++audio_stream_count_;
-  UpdateProcessPriority();
+  if (++audio_stream_count_ == 1) {
+    GetProcessResourceCoordinator()->SendEvent(
+        resource_coordinator::mojom::EventType::ON_PROCESS_AUDIO_STARTED);
+  }
+  // UpdateProcessPriority();
 }
 
 void RenderProcessHostImpl::OnAudioStreamRemoved() {
   DCHECK_GT(audio_stream_count_, 0);
-  --audio_stream_count_;
-  UpdateProcessPriority();
+  if (--audio_stream_count_ == 0) {
+    GetProcessResourceCoordinator()->SendEvent(
+        resource_coordinator::mojom::EventType::ON_PROCESS_AUDIO_STOPPED);
+  }
+  // UpdateProcessPriority();
+}
+
+resource_coordinator::ResourceCoordinatorInterface*
+RenderProcessHostImpl::GetProcessResourceCoordinator() {
+  if (!process_resource_coordinator_) {
+    process_resource_coordinator_ =
+        base::MakeUnique<resource_coordinator::ResourceCoordinatorInterface>(
+            ServiceManagerConnection::GetForProcess()->GetConnector(),
+            resource_coordinator::mojom::IDType::PROCESS);
+
+    process_resource_coordinator_->service()->SetPolicyCallback(
+        resource_coordinator_binding_.CreateInterfacePtrAndBind());
+  }
+
+  return process_resource_coordinator_.get();
 }
 
 bool RenderProcessHostImpl::IsForGuestsOnly() const {
   return is_for_guests_only_;
 }
 
 StoragePartition* RenderProcessHostImpl::GetStoragePartition() const {
   return storage_partition_impl_;
 }
 
@@ skipping 1127 matching lines @@
   }
 
   RendererClosedDetails details(status, exit_code);
 
   child_process_launcher_.reset();
   is_dead_ = true;
   if (route_provider_binding_.is_bound())
     route_provider_binding_.Close();
   ResetChannelProxy();
 
-  UpdateProcessPriority();
+  // UpdateProcessPriority();
   DCHECK(!is_process_backgrounded_);
 
   within_process_died_observer_ = true;
   NotificationService::current()->Notify(
       NOTIFICATION_RENDERER_PROCESS_CLOSED, Source<RenderProcessHost>(this),
       Details<RendererClosedDetails>(&details));
   for (auto& observer : observers_)
     observer.RenderProcessExited(this, status, exit_code);
   within_process_died_observer_ = false;
 
@@ skipping 62 matching lines @@
   for (auto& observer : observers_)
     observer.RenderProcessWillExit(this);
 
   Send(new ChildProcessMsg_Shutdown());
 }
 
 void RenderProcessHostImpl::SuddenTerminationChanged(bool enabled) {
   SetSuddenTerminationAllowed(enabled);
 }
 
-void RenderProcessHostImpl::UpdateProcessPriority() {
+void RenderProcessHostImpl::SetPolicy(
+    resource_coordinator::mojom::PolicyPtr policy) {
+  SetProcessPriority(policy->use_background_priority);
+}
+
+void RenderProcessHostImpl::SetProcessPriority(bool should_background) {
+  LOG(ERROR) << "RenderProcessHostImpl::SetProcessPriority("
+             << should_background << ")";
   if (!child_process_launcher_.get() || child_process_launcher_->IsStarting()) {
     is_process_backgrounded_ = false;
     return;
   }
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableRendererPriorityManagement)) {
     return;
   }
 
-  // We background a process as soon as it hosts no active audio streams and no
-  // visible widgets -- the callers must call this function whenever we
-  // transition in/out of those states.
-  const bool should_background =
-      visible_widgets_ == 0 && audio_stream_count_ == 0 &&
-      !base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableRendererBackgrounding);
+// We background a process as soon as it hosts no active audio streams and no
+// visible widgets -- the callers must call this function whenever we
+// transition in/out of those states.
+// const bool should_background =
+//     visible_widgets_ == 0 && audio_stream_count_ == 0 &&
+//     !base::CommandLine::ForCurrentProcess()->HasSwitch(
+//         switches::kDisableRendererBackgrounding);
 
 // TODO(sebsg): Remove this ifdef when https://crbug.com/537671 is fixed.
 #if !defined(OS_ANDROID)
   if (is_process_backgrounded_ == should_background)
     return;
 #endif
 
   TRACE_EVENT1("renderer_host", "RenderProcessHostImpl::UpdateProcessPriority",
                "should_background", should_background);
   is_process_backgrounded_ = should_background;
@@ skipping 11 matching lines @@
 
   // Control the background state from the browser process, otherwise the task
   // telling the renderer to "unbackground" itself may be preempted by other
   // tasks executing at lowered priority ahead of it or simply by not being
   // swiftly scheduled by the OS per the low process priority
   // (http://crbug.com/398103).
   child_process_launcher_->SetProcessBackgrounded(should_background);
 
   // Notify the child process of background state.
   Send(new ChildProcessMsg_SetProcessBackgrounded(should_background));
+  LOG(ERROR) << "RenderProcessHostImpl::SetProcessPriority: SUCCESS!";
 }
 
 void RenderProcessHostImpl::OnProcessLaunched() {
   // No point doing anything, since this object will be destructed soon.  We
   // especially don't want to send the RENDERER_PROCESS_CREATED notification,
   // since some clients might expect a RENDERER_PROCESS_TERMINATED afterwards to
   // properly cleanup.
   if (deleting_soon_)
     return;
 
@@ skipping 195 matching lines @@
   LOG(ERROR) << "Terminating render process for bad Mojo message: " << error;
 
   // The ReceivedBadMessage call below will trigger a DumpWithoutCrashing.
   // Capture the error message in a crash key value.
   base::debug::ScopedCrashKey error_key_value("mojo-message-error", error);
   bad_message::ReceivedBadMessage(render_process_id,
                                   bad_message::RPH_MOJO_PROCESS_ERROR);
 }
 
 }  // namespace content