Re-land chromeos: Add non-extension renderers to the freezer cgroup

chromeos/dbus/power_manager_client.cc

 // Copyright (c) 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.
 
 #include "chromeos/dbus/power_manager_client.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 64 matching lines @@
   }
 
   virtual void RemoveObserver(Observer* observer) override {
     observers_.RemoveObserver(observer);
   }
 
   virtual bool HasObserver(const Observer* observer) const override {
     return observers_.HasObserver(observer);
   }
 
+  virtual void SetRenderProcessManagerDelegate(
+      base::WeakPtr<RenderProcessManagerDelegate> delegate) override {
+    DCHECK(!render_process_manager_delegate_)
+        << "There can be only one! ...RenderProcessManagerDelegate";
+    render_process_manager_delegate_ = delegate;
+  }
+
   virtual void DecreaseScreenBrightness(bool allow_off) override {
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
         power_manager::kDecreaseScreenBrightnessMethod);
     dbus::MessageWriter writer(&method_call);
     writer.AppendBool(allow_off);
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
@@ skipping 432 matching lines @@
       LOG(ERROR) << "Unable to decode protocol buffer from "
                  << power_manager::kSuspendDoneSignal << " signal";
       return;
     }
 
     const base::TimeDelta duration =
         base::TimeDelta::FromInternalValue(proto.suspend_duration());
     VLOG(1) << "Got " << power_manager::kSuspendDoneSignal << " signal:"
             << " suspend_id=" << proto.suspend_id()
             << " duration=" << duration.InSeconds() << " sec";
+
+    if (render_process_manager_delegate_)
+      render_process_manager_delegate_->SuspendDone();
+
     FOR_EACH_OBSERVER(
         PowerManagerClient::Observer, observers_, SuspendDone(duration));
     base::PowerMonitorDeviceSource::HandleSystemResumed();
   }
 
   void IdleActionImminentReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     power_manager::IdleActionImminent proto;
     if (!reader.PopArrayOfBytesAsProto(&proto)) {
       LOG(ERROR) << "Unable to decode protocol buffer from "
@@ skipping 125 matching lines @@
     std::string method_name;
     int32_t delay_id = -1;
     if (suspending_from_dark_resume_) {
       method_name = power_manager::kHandleDarkSuspendReadinessMethod;
       delay_id = dark_suspend_delay_id_;
     } else {
       method_name = power_manager::kHandleSuspendReadinessMethod;
       delay_id = suspend_delay_id_;
     }
 
+    if (render_process_manager_delegate_ && !suspending_from_dark_resume_)
+      render_process_manager_delegate_->SuspendImminent();
+
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface, method_name);
     dbus::MessageWriter writer(&method_call);
 
     VLOG(1) << "Announcing readiness of suspend delay " << delay_id
             << " for suspend attempt " << pending_suspend_id_;
     power_manager::SuspendReadinessInfo protobuf_request;
     protobuf_request.set_delay_id(delay_id);
     protobuf_request.set_suspend_id(pending_suspend_id_);
 
@@ skipping 36 matching lines @@
   bool suspending_from_dark_resume_;
 
   // Number of callbacks that have been returned by
   // GetSuspendReadinessCallback() during the currently-pending suspend
   // attempt but have not yet been called.
   int num_pending_suspend_readiness_callbacks_;
 
   // Last state passed to SetIsProjecting().
   bool last_is_projecting_;
 
+  // The delegate used to manage the power consumption of Chrome's renderer
+  // processes.
+  base::WeakPtr<RenderProcessManagerDelegate> render_process_manager_delegate_;
+
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<PowerManagerClientImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerManagerClientImpl);
 };
 
 // The PowerManagerClient implementation used on Linux desktop,
 // which does nothing.
 class PowerManagerClientStubImpl : public PowerManagerClient {
@@ skipping 29 matching lines @@
   }
 
   virtual void RemoveObserver(Observer* observer) override {
     observers_.RemoveObserver(observer);
   }
 
   virtual bool HasObserver(const Observer* observer) const override {
     return observers_.HasObserver(observer);
   }
 
+  virtual void SetRenderProcessManagerDelegate(
+      base::WeakPtr<RenderProcessManagerDelegate> delegate) override {
+  }
+
   virtual void DecreaseScreenBrightness(bool allow_off) override {
     VLOG(1) << "Requested to descrease screen brightness";
     SetBrightness(brightness_ - 5.0, true);
   }
 
   virtual void IncreaseScreenBrightness() override {
     VLOG(1) << "Requested to increase screen brightness";
     SetBrightness(brightness_ + 5.0, true);
   }
 
@@ skipping 173 matching lines @@
 // static
 PowerManagerClient* PowerManagerClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new PowerManagerClientImpl();
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new PowerManagerClientStubImpl();
 }
 
 }  // namespace chromeos