components/html_viewer/web_layer_tree_view_impl.cc

   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 #include "components/html_viewer/web_layer_tree_view_impl.h"
   6
   7 #include "base/thread_task_runner_handle.h"
   8 #include "cc/blink/web_layer_impl.h"
   9 #include "cc/layers/layer.h"
  10 #include "cc/output/begin_frame_args.h"
  11 #include "cc/scheduler/begin_frame_source.h"
  12 #include "cc/trees/layer_tree_host.h"
  13 #include "components/view_manager/public/cpp/view.h"
  14 #include "mojo/cc/context_provider_mojo.h"
  15 #include "mojo/cc/output_surface_mojo.h"
  16 #include "mojo/converters/surfaces/surfaces_type_converters.h"
  17 #include "third_party/WebKit/public/web/WebWidget.h"
  18
  19 namespace html_viewer {
  20
  21 WebLayerTreeViewImpl::WebLayerTreeViewImpl(
  22     scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
  23     mojo::SurfacePtr surface,
  24     mojo::GpuPtr gpu_service)
  25     : widget_(NULL),
  26       view_(NULL),
  27       main_thread_compositor_task_runner_(base::ThreadTaskRunnerHandle::Get()),
  28       weak_factory_(this) {
  29   main_thread_bound_weak_ptr_ = weak_factory_.GetWeakPtr();
  30
  31   cc::LayerTreeSettings settings;
  32
  33   // For web contents, layer transforms should scale up the contents of layers
  34   // to keep content always crisp when possible.
  35   settings.layer_transforms_should_scale_layer_contents = true;
  36
  37   cc::SharedBitmapManager* shared_bitmap_manager = nullptr;
  38   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager = nullptr;
  39   cc::TaskGraphRunner* task_graph_runner = nullptr;
  40
  41   cc::LayerTreeHost::InitParams params;
  42   params.client = this;
  43   params.shared_bitmap_manager = shared_bitmap_manager;
  44   params.gpu_memory_buffer_manager = gpu_memory_buffer_manager;
  45   params.settings = &settings;
  46   params.task_graph_runner = task_graph_runner;
  47   params.main_task_runner = main_thread_compositor_task_runner_;
  48
  49   layer_tree_host_ =
  50       cc::LayerTreeHost::CreateThreaded(compositor_task_runner, &params);
  51   DCHECK(layer_tree_host_);
  52
  53   if (surface && gpu_service) {
  54     mojo::CommandBufferPtr cb;
  55     gpu_service->CreateOffscreenGLES2Context(GetProxy(&cb));
  56     scoped_refptr<cc::ContextProvider> context_provider(
  57         new mojo::ContextProviderMojo(cb.PassInterface().PassHandle()));
  58     output_surface_.reset(
  59         new mojo::OutputSurfaceMojo(this, context_provider, surface.Pass()));
  60   }
  61   layer_tree_host_->SetLayerTreeHostClientReady();
  62 }
  63
  64 WebLayerTreeViewImpl::~WebLayerTreeViewImpl() {
  65 }
  66
  67 void WebLayerTreeViewImpl::WillBeginMainFrame() {
  68 }
  69
  70 void WebLayerTreeViewImpl::DidBeginMainFrame() {
  71 }
  72
  73 void WebLayerTreeViewImpl::BeginMainFrameNotExpectedSoon() {
  74 }
  75
  76 void WebLayerTreeViewImpl::BeginMainFrame(const cc::BeginFrameArgs& args) {
  77   VLOG(2) << "WebLayerTreeViewImpl::BeginMainFrame";
  78   double frame_time_sec = (args.frame_time - base::TimeTicks()).InSecondsF();
  79   double deadline_sec = (args.deadline - base::TimeTicks()).InSecondsF();
  80   double interval_sec = args.interval.InSecondsF();
  81   blink::WebBeginFrameArgs web_begin_frame_args(
  82       frame_time_sec, deadline_sec, interval_sec);
  83   widget_->beginFrame(web_begin_frame_args);
  84 }
  85
  86 void WebLayerTreeViewImpl::Layout() {
  87   widget_->layout();
  88 }
  89
  90 void WebLayerTreeViewImpl::ApplyViewportDeltas(
  91     const gfx::Vector2dF& inner_delta,
  92     const gfx::Vector2dF& outer_delta,
  93     const gfx::Vector2dF& elastic_overscroll_delta,
  94     float page_scale,
  95     float top_controls_delta) {
  96   widget_->applyViewportDeltas(
  97       inner_delta,
  98       outer_delta,
  99       elastic_overscroll_delta,
 100       page_scale,
 101       top_controls_delta);
 102 }
 103
 104 void WebLayerTreeViewImpl::RequestNewOutputSurface() {
 105   if (output_surface_.get())
 106     layer_tree_host_->SetOutputSurface(output_surface_.Pass());
 107 }
 108
 109 void WebLayerTreeViewImpl::DidFailToInitializeOutputSurface() {
 110   RequestNewOutputSurface();
 111 }
 112
 113 void WebLayerTreeViewImpl::DidInitializeOutputSurface() {
 114 }
 115
 116 void WebLayerTreeViewImpl::WillCommit() {
 117 }
 118
 119 void WebLayerTreeViewImpl::DidCommit() {
 120 }
 121
 122 void WebLayerTreeViewImpl::DidCommitAndDrawFrame() {
 123 }
 124
 125 void WebLayerTreeViewImpl::DidCompleteSwapBuffers() {
 126 }
 127
 128 void WebLayerTreeViewImpl::setRootLayer(const blink::WebLayer& layer) {
 129   layer_tree_host_->SetRootLayer(
 130       static_cast<const cc_blink::WebLayerImpl*>(&layer)->layer());
 131 }
 132
 133 void WebLayerTreeViewImpl::clearRootLayer() {
 134   layer_tree_host_->SetRootLayer(scoped_refptr<cc::Layer>());
 135 }
 136
 137 void WebLayerTreeViewImpl::setViewportSize(
 138     const blink::WebSize& device_viewport_size) {
 139   layer_tree_host_->SetViewportSize(device_viewport_size);
 140 }
 141
 142 blink::WebSize WebLayerTreeViewImpl::deviceViewportSize() const {
 143   return layer_tree_host_->device_viewport_size();
 144 }
 145
 146 void WebLayerTreeViewImpl::setDeviceScaleFactor(float device_scale_factor) {
 147   layer_tree_host_->SetDeviceScaleFactor(device_scale_factor);
 148 }
 149
 150 float WebLayerTreeViewImpl::deviceScaleFactor() const {
 151   return layer_tree_host_->device_scale_factor();
 152 }
 153
 154 void WebLayerTreeViewImpl::setBackgroundColor(blink::WebColor color) {
 155   layer_tree_host_->set_background_color(color);
 156 }
 157
 158 void WebLayerTreeViewImpl::setHasTransparentBackground(
 159     bool has_transparent_background) {
 160   layer_tree_host_->set_has_transparent_background(has_transparent_background);
 161 }
 162
 163 void WebLayerTreeViewImpl::setVisible(bool visible) {
 164   layer_tree_host_->SetVisible(visible);
 165 }
 166
 167 void WebLayerTreeViewImpl::setPageScaleFactorAndLimits(float page_scale_factor,
 168                                                        float minimum,
 169                                                        float maximum) {
 170   layer_tree_host_->SetPageScaleFactorAndLimits(
 171       page_scale_factor, minimum, maximum);
 172 }
 173
 174 void WebLayerTreeViewImpl::registerForAnimations(blink::WebLayer* layer) {
 175   cc::Layer* cc_layer = static_cast<cc_blink::WebLayerImpl*>(layer)->layer();
 176   cc_layer->RegisterForAnimations(layer_tree_host_->animation_registrar());
 177 }
 178
 179 void WebLayerTreeViewImpl::registerViewportLayers(
 180     const blink::WebLayer* overscrollElasticityLayer,
 181     const blink::WebLayer* pageScaleLayer,
 182     const blink::WebLayer* innerViewportScrollLayer,
 183     const blink::WebLayer* outerViewportScrollLayer) {
 184   layer_tree_host_->RegisterViewportLayers(
 185       // The scroll elasticity layer will only exist when using pinch virtual
 186       // viewports.
 187       overscrollElasticityLayer
 188           ? static_cast<const cc_blink::WebLayerImpl*>(
 189                 overscrollElasticityLayer)->layer()
 190           : NULL,
 191       static_cast<const cc_blink::WebLayerImpl*>(pageScaleLayer)->layer(),
 192       static_cast<const cc_blink::WebLayerImpl*>(innerViewportScrollLayer)
 193           ->layer(),
 194       // The outer viewport layer will only exist when using pinch virtual
 195       // viewports.
 196       outerViewportScrollLayer
 197           ? static_cast<const cc_blink::WebLayerImpl*>(outerViewportScrollLayer)
 198                 ->layer()
 199           : NULL);
 200 }
 201
 202 void WebLayerTreeViewImpl::clearViewportLayers() {
 203   layer_tree_host_->RegisterViewportLayers(scoped_refptr<cc::Layer>(),
 204                                            scoped_refptr<cc::Layer>(),
 205                                            scoped_refptr<cc::Layer>(),
 206                                            scoped_refptr<cc::Layer>());
 207 }
 208
 209 void WebLayerTreeViewImpl::startPageScaleAnimation(
 210     const blink::WebPoint& destination,
 211     bool use_anchor,
 212     float new_page_scale,
 213     double duration_sec) {
 214   base::TimeDelta duration = base::TimeDelta::FromMicroseconds(
 215       duration_sec * base::Time::kMicrosecondsPerSecond);
 216   layer_tree_host_->StartPageScaleAnimation(
 217       gfx::Vector2d(destination.x, destination.y),
 218       use_anchor,
 219       new_page_scale,
 220       duration);
 221 }
 222
 223 void WebLayerTreeViewImpl::setNeedsAnimate() {
 224   layer_tree_host_->SetNeedsAnimate();
 225 }
 226
 227 bool WebLayerTreeViewImpl::commitRequested() const {
 228   return layer_tree_host_->CommitRequested();
 229 }
 230
 231 void WebLayerTreeViewImpl::finishAllRendering() {
 232   layer_tree_host_->FinishAllRendering();
 233 }
 234
 235 void WebLayerTreeViewImpl::DidCreateSurface(cc::SurfaceId id) {
 236   main_thread_compositor_task_runner_->PostTask(
 237       FROM_HERE,
 238       base::Bind(&WebLayerTreeViewImpl::DidCreateSurfaceOnMainThread,
 239                  main_thread_bound_weak_ptr_,
 240                  id));
 241 }
 242
 243 void WebLayerTreeViewImpl::DidCreateSurfaceOnMainThread(cc::SurfaceId id) {
 244   view_->SetSurfaceId(mojo::SurfaceId::From(id));
 245 }
 246
 247 }  // namespace html_viewer