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 RequestNewOutputSurface() override;
  81   void DidInitializeOutputSurface() override;
  82   void DidFailToInitializeOutputSurface() override;
  83   void WillCommit() override {}
  84   void DidCommit() override;
  85   void DidCommitAndDrawFrame() override {}
  86   void DidCompleteSwapBuffers() override;
  87   void DidCompletePageScaleAnimation() override {}
  88   void RecordFrameTimingEvents(
  89       scoped_ptr<cc::FrameTimingTracker::CompositeTimingSet> composite_events,
  90       scoped_ptr<cc::FrameTimingTracker::MainFrameTimingSet> main_frame_events)
  91       override {}
  92
  93   // LayerTreeHostSingleThreadClient implementation.
  94   void ScheduleComposite() override;
  95   void ScheduleAnimation() override;
  96   void DidPostSwapBuffers() override;
  97   void DidAbortSwapBuffers() override;
  98
  99   // WindowAndroidCompositor implementation.
 100   void AttachLayerForReadback(scoped_refptr<cc::Layer> layer) override;
 101   void RequestCopyOfOutputOnRootLayer(
 102       scoped_ptr<cc::CopyOutputRequest> request) override;
 103   void OnVSync(base::TimeTicks frame_time,
 104                base::TimeDelta vsync_period) override;
 105   void SetNeedsAnimate() override;
 106
 107   void SetWindowSurface(ANativeWindow* window);
 108   void SetVisible(bool visible);
 109
 110   enum CompositingTrigger {
 111     DO_NOT_COMPOSITE,
 112     COMPOSITE_IMMEDIATELY,
 113     COMPOSITE_EVENTUALLY,
 114   };
 115   void PostComposite(CompositingTrigger trigger);
 116   void Composite(CompositingTrigger trigger);
 117   void CreateOutputSurface();
 118
 119   bool WillCompositeThisFrame() const {
 120     return current_composite_task_ &&
 121            !current_composite_task_->callback().is_null();
 122   }
 123   bool DidCompositeThisFrame() const {
 124     return current_composite_task_ &&
 125            current_composite_task_->callback().is_null();
 126   }
 127   bool WillComposite() const {
 128     return WillCompositeThisFrame() ||
 129            composite_on_vsync_trigger_ != DO_NOT_COMPOSITE;
 130   }
 131   void CancelComposite() {
 132     DCHECK(WillComposite());
 133     if (WillCompositeThisFrame())
 134       current_composite_task_->Cancel();
 135     current_composite_task_.reset();
 136     composite_on_vsync_trigger_ = DO_NOT_COMPOSITE;
 137     will_composite_immediately_ = false;
 138   }
 139   void CreateLayerTreeHost();
 140
 141   void OnGpuChannelEstablished();
 142   void OnGpuChannelTimeout();
 143
 144   // root_layer_ is the persistent internal root layer, while subroot_layer_
 145   // is the one attached by the compositor client.
 146   scoped_refptr<cc::Layer> root_layer_;
 147   scoped_refptr<cc::Layer> subroot_layer_;
 148
 149   scoped_ptr<cc::LayerTreeHost> host_;
 150   ui::UIResourceProvider ui_resource_provider_;
 151   ui::ResourceManagerImpl resource_manager_;
 152
 153   scoped_ptr<cc::OnscreenDisplayClient> display_client_;
 154   scoped_ptr<cc::SurfaceIdAllocator> surface_id_allocator_;
 155
 156   gfx::Size size_;
 157   bool has_transparent_background_;
 158   float device_scale_factor_;
 159
 160   ANativeWindow* window_;
 161   int surface_id_;
 162
 163   CompositorClient* client_;
 164
 165   gfx::NativeWindow root_window_;
 166
 167   // Used locally to track whether a call to LTH::Composite() did result in
 168   // a posted SwapBuffers().
 169   bool did_post_swapbuffers_;
 170
 171   // Used locally to inhibit ScheduleComposite() during Layout().
 172   bool ignore_schedule_composite_;
 173
 174   // Whether we need to composite in general because of any invalidation or
 175   // explicit request.
 176   bool needs_composite_;
 177
 178   // Whether we need to update animations on the next composite.
 179   bool needs_animate_;
 180
 181   // Whether we posted a task and are about to composite.
 182   bool will_composite_immediately_;
 183
 184   // How we should schedule Composite during the next vsync.
 185   CompositingTrigger composite_on_vsync_trigger_;
 186
 187   // The Composite operation scheduled for the current vsync interval.
 188   scoped_ptr<base::CancelableClosure> current_composite_task_;
 189
 190   // The number of SwapBuffer calls that have not returned and ACK'd from
 191   // the GPU thread.
 192   unsigned int pending_swapbuffers_;
 193
 194   size_t num_successive_context_creation_failures_;
 195
 196   base::TimeDelta vsync_period_;
 197   base::TimeTicks last_vsync_;
 198
 199   base::OneShotTimer<CompositorImpl> establish_gpu_channel_timeout_;
 200
 201   // Whether there is an OutputSurface request pending from the current
 202   // |host_|. Becomes |true| if RequestNewOutputSurface is called, and |false|
 203   // if |host_| is deleted or we succeed in creating *and* initializing an
 204   // OutputSurface (which is essentially the contract with cc).
 205   bool output_surface_request_pending_;
 206
 207   base::WeakPtrFactory<CompositorImpl> weak_factory_;
 208
 209   DISALLOW_COPY_AND_ASSIGN(CompositorImpl);
 210 };
 211
 212 } // namespace content
 213
 214 #endif  // CONTENT_BROWSER_RENDERER_HOST_COMPOSITOR_IMPL_ANDROID_H_