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 929 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)),
       frame_sink_provider_(id_),
       weak_factory_(this) {
   widget_helper_ = new RenderWidgetHelper();
 
   ChildProcessSecurityPolicyImpl::GetInstance()->Add(GetID());
 
   CHECK(!BrowserMainRunner::ExitedMainMessageLoop());
   RegisterHost(GetID(), this);
@@ skipping 847 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();
 }
 
 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) {
-    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::EventType::kOnProcessAudioStarted);
+  }
+  // UpdateProcessPriority();
 }
 
 void RenderProcessHostImpl::OnAudioStreamRemoved() {
   DCHECK_GT(audio_stream_count_, 0);
-  --audio_stream_count_;
-  UpdateProcessPriority();
+  if (--audio_stream_count_ == 0) {
+    GetProcessResourceCoordinator()->SendEvent(
+        resource_coordinator::EventType::kOnProcessAudioStopped);
+  }
+  // UpdateProcessPriority();
+}
+
+resource_coordinator::ResourceCoordinatorInterface*
+RenderProcessHostImpl::GetProcessResourceCoordinator() {
+  if (!process_resource_coordinator_) {
+    process_resource_coordinator_ =
+        base::MakeUnique<resource_coordinator::ResourceCoordinatorInterface>(
+            ServiceManagerConnection::GetForProcess()->GetConnector(),
+            resource_coordinator::CoordinationUnitType::kProcess);
+
+    process_resource_coordinator_->service()->SetCoordinationPolicyCallback(
+        resource_coordinator_binding_.CreateInterfacePtrAndBind());
+  }
+
+  return process_resource_coordinator_.get();
 }
 
 void RenderProcessHostImpl::set_render_process_host_factory(
     const RenderProcessHostFactory* rph_factory) {
   g_render_process_host_factory_ = rph_factory;
 }
 
 // static
 void RenderProcessHostImpl::AddFrameWithSite(
     BrowserContext* browser_context,
@@ skipping 757 matching lines @@
   // Remove ourself from the list of renderer processes so that we can't be
   // reused in between now and when the Delete task runs.
   UnregisterHost(GetID());
 
   instance_weak_factory_.reset(
       new base::WeakPtrFactory<RenderProcessHostImpl>(this));
 }
 
 void RenderProcessHostImpl::AddPendingView() {
   pending_views_++;
-  UpdateProcessPriority();
+  // UpdateProcessPriority();
 }
 
 void RenderProcessHostImpl::RemovePendingView() {
   DCHECK(pending_views_);
   pending_views_--;
-  UpdateProcessPriority();
+  // UpdateProcessPriority();
 }
 
 void RenderProcessHostImpl::AddWidget(RenderWidgetHost* widget) {
   widgets_.insert(static_cast<RenderWidgetHostImpl*>(widget));
 }
 
 void RenderProcessHostImpl::RemoveWidget(RenderWidgetHost* widget) {
   widgets_.erase(static_cast<RenderWidgetHostImpl*>(widget));
 }
 
@@ skipping 506 matching lines @@
 
   RendererClosedDetails details(status, exit_code);
 
   child_process_launcher_.reset();
   is_dead_ = true;
   if (route_provider_binding_.is_bound())
     route_provider_binding_.Close();
   associated_interfaces_.reset();
   ResetChannelProxy();
 
-  UpdateProcessPriority();
+  // UpdateProcessPriority();
 
   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;
 
   RemoveUserData(kSessionStorageHolderKey);
@@ skipping 72 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::SetCoordinationPolicy(
+    resource_coordinator::mojom::CoordinationPolicyPtr 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_ = kLaunchingProcessIsBackgrounded;
     boost_priority_for_pending_views_ =
         kLaunchingProcessIsBoostedForPendingView;
     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);
+  // const bool should_background =
+  //     visible_widgets_ == 0 && audio_stream_count_ == 0 &&
+  //     !base::CommandLine::ForCurrentProcess()->HasSwitch(
+  //         switches::kDisableRendererBackgrounding);
   const bool should_background_changed =
       is_process_backgrounded_ != should_background;
   const bool has_pending_views = !!pending_views_;
 
   if (!should_background_changed &&
       boost_priority_for_pending_views_ == has_pending_views) {
     return;
   }
 
   TRACE_EVENT2("renderer_host", "RenderProcessHostImpl::UpdateProcessPriority",
@@ skipping 17 matching lines @@
   // 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_->SetProcessPriority(should_background,
                                               has_pending_views);
 
   // Notify the child process of background state. Note
   // |boost_priority_for_pending_views_| state is not sent to renderer simply
   // due to lack of need.
-  if (should_background_changed)
+  if (should_background_changed) {
     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 258 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