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