chrome/browser/chromeos/power/renderer_freezer.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_CHROMEOS_POWER_RENDERER_FREEZER_H_
   6 #define CHROME_BROWSER_CHROMEOS_POWER_RENDERER_FREEZER_H_
   7
   8 #include <set>
   9
  10 #include "base/callback.h"
  11 #include "base/cancelable_callback.h"
  12 #include "base/macros.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "base/process/kill.h"
  16 #include "base/time/time.h"
  17 #include "chromeos/chromeos_export.h"
  18 #include "chromeos/dbus/power_manager_client.h"
  19 #include "content/public/browser/notification_observer.h"
  20 #include "content/public/browser/notification_registrar.h"
  21 #include "content/public/browser/render_process_host_observer.h"
  22
  23 namespace content {
  24 class RenderProcessHost;
  25 }
  26
  27 namespace chromeos {
  28
  29 class ScreenLocker;
  30
  31 // Freezes the chrome renderers when the system is about to suspend and thaws
  32 // them after the system fully resumes.  This class registers itself as a
  33 // PowerManagerClient::Observer on creation and unregisters itself on
  34 // destruction.
  35 class CHROMEOS_EXPORT RendererFreezer
  36     : public PowerManagerClient::RenderProcessManagerDelegate,
  37       public content::NotificationObserver,
  38       public content::RenderProcessHostObserver {
  39  public:
  40   class Delegate {
  41    public:
  42     typedef base::Callback<void(bool)> ResultCallback;
  43
  44     virtual ~Delegate() {}
  45
  46     // If |frozen| is true, marks the renderer process |handle| to be frozen
  47     // when FreezeRenderers() is called; otherwise marks it to remain unfrozen.
  48     // Performs the operation asynchronously on the FILE thread.
  49     virtual void SetShouldFreezeRenderer(base::ProcessHandle handle,
  50                                          bool frozen) = 0;
  51
  52     // Freezes the renderers marked for freezing by SetShouldFreezeRenderer().
  53     // Performs the operation asynchronously on the FILE thread.
  54     virtual void FreezeRenderers() = 0;
  55
  56     // Thaws the chrome renderers that were frozen by the call to
  57     // FreezeRenderers().  Performs the operation asynchronously on the FILE
  58     // thread and runs |callback| with the result on the UI thread.
  59     virtual void ThawRenderers(ResultCallback callback) = 0;
  60
  61     // Asynchronously checks on the FILE thread if the delegate can freeze
  62     // renderers and runs |callback| on the UI thread with the result.
  63     virtual void CheckCanFreezeRenderers(ResultCallback callback) = 0;
  64   };
  65
  66   explicit RendererFreezer(scoped_ptr<Delegate> delegate);
  67   ~RendererFreezer() override;
  68
  69   // PowerManagerClient::RenderProcessManagerDelegate implementation.
  70   void SuspendImminent() override;
  71   void SuspendDone() override;
  72
  73   // content::NotificationObserver implementation.
  74   void Observe(int type,
  75                const content::NotificationSource& source,
  76                const content::NotificationDetails& details) override;
  77
  78   // content::RenderProcessHostObserver overrides.
  79   void RenderProcessExited(content::RenderProcessHost* host,
  80                            base::TerminationStatus status,
  81                            int exit_code) override;
  82   void RenderProcessHostDestroyed(content::RenderProcessHost* host) override;
  83
  84  private:
  85   // Called after checking if the delegate is capable of freezing renderers.
  86   void OnCheckCanFreezeRenderersComplete(bool can_freeze);
  87
  88   // Called after thawing the renderers has completed.
  89   void OnThawRenderersComplete(bool success);
  90
  91   // Called whenever the screen locker is shown or hidden.
  92   void OnScreenLockStateChanged(chromeos::ScreenLocker* locker, bool is_locked);
  93
  94   // Called whenever a new renderer process is created.
  95   void OnRenderProcessCreated(content::RenderProcessHost* rph);
  96
  97   // Delegate that takes care of actually freezing and thawing renderers for us.
  98   scoped_ptr<Delegate> delegate_;
  99
 100   // Set that keeps track of the RenderProcessHosts for processes that are
 101   // hosting GCM extensions.
 102   std::set<int> gcm_extension_processes_;
 103
 104   // Manages notification registrations.
 105   content::NotificationRegistrar registrar_;
 106
 107   base::WeakPtrFactory<RendererFreezer> weak_factory_;
 108
 109   DISALLOW_COPY_AND_ASSIGN(RendererFreezer);
 110 };
 111
 112 }  // namespace chromeos
 113
 114 #endif  // CHROME_BROWSER_CHROMEOS_POWER_RENDERER_FREEZER_H_