components/view_manager/display_manager.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 COMPONENTS_VIEW_MANAGER_DISPLAY_MANAGER_H_
   6 #define COMPONENTS_VIEW_MANAGER_DISPLAY_MANAGER_H_
   7
   8 #include <map>
   9
  10 #include "base/basictypes.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/timer/timer.h"
  14 #include "components/view_manager/display_manager_delegate.h"
  15 #include "components/view_manager/public/interfaces/view_manager.mojom.h"
  16 #include "components/view_manager/surfaces/top_level_display_client.h"
  17 #include "third_party/mojo/src/mojo/public/cpp/bindings/callback.h"
  18 #include "ui/gfx/geometry/rect.h"
  19 #include "ui/platform_window/platform_window_delegate.h"
  20
  21 namespace cc {
  22 class SurfaceIdAllocator;
  23 class SurfaceManager;
  24 }  // namespace cc
  25
  26 namespace gles2 {
  27 class GpuState;
  28 }  // namespace gles2
  29
  30 namespace mojo {
  31 class ApplicationImpl;
  32 }  // namespace mojo
  33
  34 namespace surfaces {
  35 class SurfacesScheduler;
  36 class SurfacesState;
  37 }  // namespace surfaces
  38
  39 namespace ui {
  40 class PlatformWindow;
  41 struct TextInputState;
  42 }  // namespace ui
  43
  44 namespace view_manager {
  45
  46 class DisplayManagerFactory;
  47 class EventDispatcher;
  48 class ServerView;
  49
  50 // DisplayManager is used to connect the root ServerView to a display.
  51 class DisplayManager {
  52  public:
  53   virtual ~DisplayManager() {}
  54
  55   static DisplayManager* Create(
  56       bool is_headless,
  57       mojo::ApplicationImpl* app_impl,
  58       const scoped_refptr<gles2::GpuState>& gpu_state,
  59       const scoped_refptr<surfaces::SurfacesState>& surfaces_state);
  60
  61   virtual void Init(DisplayManagerDelegate* delegate) = 0;
  62
  63   // Schedules a paint for the specified region in the coordinates of |view|.
  64   virtual void SchedulePaint(const ServerView* view,
  65                              const gfx::Rect& bounds) = 0;
  66
  67   virtual void SetViewportSize(const gfx::Size& size) = 0;
  68
  69   virtual const mojo::ViewportMetrics& GetViewportMetrics() = 0;
  70
  71   virtual void UpdateTextInputState(const ui::TextInputState& state) = 0;
  72   virtual void SetImeVisibility(bool visible) = 0;
  73
  74   // Overrides factory for testing. Default (NULL) value indicates regular
  75   // (non-test) environment.
  76   static void set_factory_for_testing(DisplayManagerFactory* factory) {
  77     DisplayManager::factory_ = factory;
  78   }
  79
  80  private:
  81   // Static factory instance (always NULL for non-test).
  82   static DisplayManagerFactory* factory_;
  83 };
  84
  85 // DisplayManager implementation that connects to the services necessary to
  86 // actually display.
  87 class DefaultDisplayManager :
  88     public DisplayManager,
  89     public ui::PlatformWindowDelegate {
  90  public:
  91   DefaultDisplayManager(
  92       bool is_headless,
  93       mojo::ApplicationImpl* app_impl,
  94       const scoped_refptr<gles2::GpuState>& gpu_state,
  95       const scoped_refptr<surfaces::SurfacesState>& surfaces_state);
  96   ~DefaultDisplayManager() override;
  97
  98   // DisplayManager:
  99   void Init(DisplayManagerDelegate* delegate) override;
 100   void SchedulePaint(const ServerView* view, const gfx::Rect& bounds) override;
 101   void SetViewportSize(const gfx::Size& size) override;
 102   const mojo::ViewportMetrics& GetViewportMetrics() override;
 103   void UpdateTextInputState(const ui::TextInputState& state) override;
 104   void SetImeVisibility(bool visible) override;
 105
 106  private:
 107   void WantToDraw();
 108   void Draw();
 109   void DidDraw();
 110   void UpdateMetrics(const gfx::Size& size, float device_pixel_ratio);
 111
 112   // ui::PlatformWindowDelegate:
 113   void OnBoundsChanged(const gfx::Rect& new_bounds) override;
 114   void OnDamageRect(const gfx::Rect& damaged_region) override;
 115   void DispatchEvent(ui::Event* event) override;
 116   void OnCloseRequest() override;
 117   void OnClosed() override;
 118   void OnWindowStateChanged(ui::PlatformWindowState new_state) override;
 119   void OnLostCapture() override;
 120   void OnAcceleratedWidgetAvailable(gfx::AcceleratedWidget widget,
 121                                     float device_pixel_ratio) override;
 122   void OnActivationChanged(bool active) override;
 123
 124   bool is_headless_;
 125   mojo::ApplicationImpl* app_impl_;
 126   scoped_refptr<gles2::GpuState> gpu_state_;
 127   scoped_refptr<surfaces::SurfacesState> surfaces_state_;
 128   DisplayManagerDelegate* delegate_;
 129
 130   mojo::ViewportMetrics metrics_;
 131   gfx::Rect dirty_rect_;
 132   base::Timer draw_timer_;
 133   bool frame_pending_;
 134
 135   scoped_ptr<surfaces::TopLevelDisplayClient> top_level_display_client_;
 136   scoped_ptr<ui::PlatformWindow> platform_window_;
 137
 138   DISALLOW_COPY_AND_ASSIGN(DefaultDisplayManager);
 139 };
 140
 141 }  // namespace view_manager
 142
 143 #endif  // COMPONENTS_VIEW_MANAGER_DISPLAY_MANAGER_H_