content/browser/renderer_host/compositor_impl_android.h

   1 // Copyright (c) 2012 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 CONTENT_BROWSER_RENDERER_HOST_COMPOSITOR_IMPL_ANDROID_H_
   6 #define CONTENT_BROWSER_RENDERER_HOST_COMPOSITOR_IMPL_ANDROID_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/cancelable_callback.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/timer/timer.h"
  14 #include "cc/trees/layer_tree_host_client.h"
  15 #include "cc/trees/layer_tree_host_single_thread_client.h"
  16 #include "content/common/content_export.h"
  17 #include "content/common/gpu/client/context_provider_command_buffer.h"
  18 #include "content/public/browser/android/compositor.h"
  19 #include "gpu/command_buffer/common/capabilities.h"
  20 #include "third_party/khronos/GLES2/gl2.h"
  21 #include "ui/android/resources/resource_manager_impl.h"
  22 #include "ui/android/resources/ui_resource_provider.h"
  23 #include "ui/android/window_android_compositor.h"
  24
  25 class SkBitmap;
  26 struct ANativeWindow;
  27
  28 namespace cc {
  29 class Layer;
  30 class LayerTreeHost;
  31 class OnscreenDisplayClient;
  32 class SurfaceIdAllocator;
  33 class SurfaceManager;
  34 }
  35
  36 namespace content {
  37 class CompositorClient;
  38
  39 // -----------------------------------------------------------------------------
  40 // Browser-side compositor that manages a tree of content and UI layers.
  41 // -----------------------------------------------------------------------------
  42 class CONTENT_EXPORT CompositorImpl
  43     : public Compositor,
  44       public cc::LayerTreeHostClient,
  45       public cc::LayerTreeHostSingleThreadClient,
  46       public ui::WindowAndroidCompositor {
  47  public:
  48   CompositorImpl(CompositorClient* client, gfx::NativeWindow root_window);
  49   ~CompositorImpl() override;
  50
  51   static bool IsInitialized();
  52
  53   static cc::SurfaceManager* GetSurfaceManager();
  54   static scoped_ptr<cc::SurfaceIdAllocator> CreateSurfaceIdAllocator();
  55
  56   void PopulateGpuCapabilities(gpu::Capabilities gpu_capabilities);
  57
  58  private:
  59   // Compositor implementation.
  60   void SetRootLayer(scoped_refptr<cc::Layer> root) override;
  61   void SetSurface(jobject surface) override;
  62   void setDeviceScaleFactor(float factor) override;
  63   void SetWindowBounds(const gfx::Size& size) override;
  64   void SetHasTransparentBackground(bool flag) override;
  65   void SetNeedsComposite() override;
  66   ui::UIResourceProvider& GetUIResourceProvider() override;
  67   ui::ResourceManager& GetResourceManager() override;
  68
  69   // LayerTreeHostClient implementation.
  70   void WillBeginMainFrame() override {}
  71   void DidBeginMainFrame() override {}
  72   void BeginMainFrame(const cc::BeginFrameArgs& args) override {}
  73   void BeginMainFrameNotExpectedSoon() override {}
  74   void Layout() override;
  75   void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
  76                            const gfx::Vector2dF& outer_delta,
  77                            const gfx::Vector2dF& elastic_overscroll_delta,
  78                            float page_scale,
  79                            float top_controls_delta) override {}
  80   void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
  81                            float page_scale,
  82                            float top_controls_delta) override {}
  83   void RequestNewOutputSurface() override;
  84   void DidInitializeOutputSurface() override;
  85   void DidFailToInitializeOutputSurface() override;
  86   void WillCommit() override {}
  87   void DidCommit() override;
  88   void DidCommitAndDrawFrame() override {}
  89   void DidCompleteSwapBuffers() override;
  90   void DidCompletePageScaleAnimation() override {}
  91
  92   // LayerTreeHostSingleThreadClient implementation.
  93   void ScheduleComposite() override;
  94   void ScheduleAnimation() override;
  95   void DidPostSwapBuffers() override;
  96   void DidAbortSwapBuffers() override;
  97
  98   // WindowAndroidCompositor implementation.
  99   void AttachLayerForReadback(scoped_refptr<cc::Layer> layer) override;
 100   void RequestCopyOfOutputOnRootLayer(
 101       scoped_ptr<cc::CopyOutputRequest> request) override;
 102   void OnVSync(base::TimeTicks frame_time,
 103                base::TimeDelta vsync_period) override;
 104   void SetNeedsAnimate() override;
 105
 106   void SetWindowSurface(ANativeWindow* window);
 107   void SetVisible(bool visible);
 108
 109   enum CompositingTrigger {
 110     DO_NOT_COMPOSITE,
 111     COMPOSITE_IMMEDIATELY,
 112     COMPOSITE_EVENTUALLY,
 113   };
 114   void PostComposite(CompositingTrigger trigger);
 115   void Composite(CompositingTrigger trigger);
 116   void CreateOutputSurface();
 117
 118   bool WillCompositeThisFrame() const {
 119     return current_composite_task_ &&
 120            !current_composite_task_->callback().is_null();
 121   }
 122   bool DidCompositeThisFrame() const {
 123     return current_composite_task_ &&
 124            current_composite_task_->callback().is_null();
 125   }
 126   bool WillComposite() const {
 127     return WillCompositeThisFrame() ||
 128            composite_on_vsync_trigger_ != DO_NOT_COMPOSITE;
 129   }
 130   void CancelComposite() {
 131     DCHECK(WillComposite());
 132     if (WillCompositeThisFrame())
 133       current_composite_task_->Cancel();
 134     current_composite_task_.reset();
 135     composite_on_vsync_trigger_ = DO_NOT_COMPOSITE;
 136     will_composite_immediately_ = false;
 137   }
 138   void CreateLayerTreeHost();
 139
 140   void OnGpuChannelEstablished();
 141   void OnGpuChannelTimeout();
 142
 143   // root_layer_ is the persistent internal root layer, while subroot_layer_
 144   // is the one attached by the compositor client.
 145   scoped_refptr<cc::Layer> root_layer_;
 146   scoped_refptr<cc::Layer> subroot_layer_;
 147
 148   scoped_ptr<cc::LayerTreeHost> host_;
 149   ui::UIResourceProvider ui_resource_provider_;
 150   ui::ResourceManagerImpl resource_manager_;
 151
 152   scoped_ptr<cc::OnscreenDisplayClient> display_client_;
 153   scoped_ptr<cc::SurfaceIdAllocator> surface_id_allocator_;
 154
 155   gfx::Size size_;
 156   bool has_transparent_background_;
 157   float device_scale_factor_;
 158
 159   ANativeWindow* window_;
 160   int surface_id_;
 161
 162   CompositorClient* client_;
 163
 164   gfx::NativeWindow root_window_;
 165
 166   // Used locally to track whether a call to LTH::Composite() did result in
 167   // a posted SwapBuffers().
 168   bool did_post_swapbuffers_;
 169
 170   // Used locally to inhibit ScheduleComposite() during Layout().
 171   bool ignore_schedule_composite_;
 172
 173   // Whether we need to composite in general because of any invalidation or
 174   // explicit request.
 175   bool needs_composite_;
 176
 177   // Whether we need to update animations on the next composite.
 178   bool needs_animate_;
 179
 180   // Whether we posted a task and are about to composite.
 181   bool will_composite_immediately_;
 182
 183   // How we should schedule Composite during the next vsync.
 184   CompositingTrigger composite_on_vsync_trigger_;
 185
 186   // The Composite operation scheduled for the current vsync interval.
 187   scoped_ptr<base::CancelableClosure> current_composite_task_;
 188
 189   // The number of SwapBuffer calls that have not returned and ACK'd from
 190   // the GPU thread.
 191   unsigned int pending_swapbuffers_;
 192
 193   size_t num_successive_context_creation_failures_;
 194
 195   base::TimeDelta vsync_period_;
 196   base::TimeTicks last_vsync_;
 197
 198   base::OneShotTimer<CompositorImpl> establish_gpu_channel_timeout_;
 199
 200   // Whether there is an OutputSurface request pending from the current
 201   // |host_|. Becomes |true| if RequestNewOutputSurface is called, and |false|
 202   // if |host_| is deleted or we succeed in creating *and* initializing an
 203   // OutputSurface (which is essentially the contract with cc).
 204   bool output_surface_request_pending_;
 205
 206   base::WeakPtrFactory<CompositorImpl> weak_factory_;
 207
 208   DISALLOW_COPY_AND_ASSIGN(CompositorImpl);
 209 };
 210
 211 } // namespace content
 212
 213 #endif  // CONTENT_BROWSER_RENDERER_HOST_COMPOSITOR_IMPL_ANDROID_H_