src/content/renderer/child_frame_compositing_helper.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 "content/renderer/child_frame_compositing_helper.h"
   6
   7 #include "cc/blink/web_layer_impl.h"
   8 #include "cc/layers/delegated_frame_provider.h"
   9 #include "cc/layers/delegated_frame_resource_collection.h"
  10 #include "cc/layers/delegated_renderer_layer.h"
  11 #include "cc/layers/solid_color_layer.h"
  12 #include "cc/output/context_provider.h"
  13 #include "cc/output/copy_output_request.h"
  14 #include "cc/output/copy_output_result.h"
  15 #include "cc/resources/single_release_callback.h"
  16 #include "content/common/browser_plugin/browser_plugin_messages.h"
  17 #include "content/common/frame_messages.h"
  18 #include "content/common/gpu/client/context_provider_command_buffer.h"
  19 #include "content/renderer/browser_plugin/browser_plugin.h"
  20 #include "content/renderer/browser_plugin/browser_plugin_manager.h"
  21 #include "content/renderer/render_frame_impl.h"
  22 #include "content/renderer/render_frame_proxy.h"
  23 #include "content/renderer/render_thread_impl.h"
  24 #include "skia/ext/image_operations.h"
  25 #include "third_party/WebKit/public/web/WebFrame.h"
  26 #include "third_party/WebKit/public/web/WebPluginContainer.h"
  27 #include "third_party/khronos/GLES2/gl2.h"
  28 #include "ui/gfx/size_conversions.h"
  29 #include "ui/gfx/skia_util.h"
  30
  31 namespace content {
  32
  33 ChildFrameCompositingHelper*
  34 ChildFrameCompositingHelper::CreateForBrowserPlugin(
  35     const base::WeakPtr<BrowserPlugin>& browser_plugin) {
  36   return new ChildFrameCompositingHelper(
  37       browser_plugin, NULL, NULL, browser_plugin->render_view_routing_id());
  38 }
  39
  40 ChildFrameCompositingHelper*
  41 ChildFrameCompositingHelper::CreateForRenderFrameProxy(
  42     RenderFrameProxy* render_frame_proxy) {
  43   return new ChildFrameCompositingHelper(base::WeakPtr<BrowserPlugin>(),
  44                                          render_frame_proxy->web_frame(),
  45                                          render_frame_proxy,
  46                                          render_frame_proxy->routing_id());
  47 }
  48
  49 ChildFrameCompositingHelper::ChildFrameCompositingHelper(
  50     const base::WeakPtr<BrowserPlugin>& browser_plugin,
  51     blink::WebFrame* frame,
  52     RenderFrameProxy* render_frame_proxy,
  53     int host_routing_id)
  54     : host_routing_id_(host_routing_id),
  55       last_route_id_(0),
  56       last_output_surface_id_(0),
  57       last_host_id_(0),
  58       ack_pending_(true),
  59       opaque_(true),
  60       browser_plugin_(browser_plugin),
  61       render_frame_proxy_(render_frame_proxy),
  62       frame_(frame) {}
  63
  64 ChildFrameCompositingHelper::~ChildFrameCompositingHelper() {}
  65
  66 BrowserPluginManager* ChildFrameCompositingHelper::GetBrowserPluginManager() {
  67   if (!browser_plugin_)
  68     return NULL;
  69
  70   return browser_plugin_->browser_plugin_manager();
  71 }
  72
  73 blink::WebPluginContainer* ChildFrameCompositingHelper::GetContainer() {
  74   if (!browser_plugin_)
  75     return NULL;
  76
  77   return browser_plugin_->container();
  78 }
  79
  80 int ChildFrameCompositingHelper::GetInstanceID() {
  81   if (!browser_plugin_)
  82     return 0;
  83
  84   return browser_plugin_->browser_plugin_instance_id();
  85 }
  86
  87 void ChildFrameCompositingHelper::SendCompositorFrameSwappedACKToBrowser(
  88     FrameHostMsg_CompositorFrameSwappedACK_Params& params) {
  89   // This function will be removed when BrowserPluginManager is removed and
  90   // BrowserPlugin is modified to use a RenderFrame.
  91   if (GetBrowserPluginManager()) {
  92     GetBrowserPluginManager()->Send(
  93         new BrowserPluginHostMsg_CompositorFrameSwappedACK(
  94             host_routing_id_, GetInstanceID(), params));
  95   } else if (render_frame_proxy_) {
  96     render_frame_proxy_->Send(
  97         new FrameHostMsg_CompositorFrameSwappedACK(host_routing_id_, params));
  98   }
  99 }
 100
 101 void ChildFrameCompositingHelper::SendReclaimCompositorResourcesToBrowser(
 102     FrameHostMsg_ReclaimCompositorResources_Params& params) {
 103   // This function will be removed when BrowserPluginManager is removed and
 104   // BrowserPlugin is modified to use a RenderFrame.
 105   if (GetBrowserPluginManager()) {
 106     GetBrowserPluginManager()->Send(
 107         new BrowserPluginHostMsg_ReclaimCompositorResources(
 108             host_routing_id_, GetInstanceID(), params));
 109   } else if (render_frame_proxy_) {
 110     render_frame_proxy_->Send(
 111         new FrameHostMsg_ReclaimCompositorResources(host_routing_id_, params));
 112   }
 113 }
 114
 115 void ChildFrameCompositingHelper::DidCommitCompositorFrame() {
 116   if (!resource_collection_.get() || !ack_pending_)
 117     return;
 118
 119   FrameHostMsg_CompositorFrameSwappedACK_Params params;
 120   params.producing_host_id = last_host_id_;
 121   params.producing_route_id = last_route_id_;
 122   params.output_surface_id = last_output_surface_id_;
 123   resource_collection_->TakeUnusedResourcesForChildCompositor(
 124       &params.ack.resources);
 125
 126   SendCompositorFrameSwappedACKToBrowser(params);
 127
 128   ack_pending_ = false;
 129 }
 130
 131 void ChildFrameCompositingHelper::EnableCompositing(bool enable) {
 132   if (enable && !background_layer_.get()) {
 133     background_layer_ = cc::SolidColorLayer::Create();
 134     background_layer_->SetMasksToBounds(true);
 135     background_layer_->SetBackgroundColor(
 136         SkColorSetARGBInline(255, 255, 255, 255));
 137     web_layer_.reset(new cc_blink::WebLayerImpl(background_layer_));
 138   }
 139
 140   if (GetContainer()) {
 141     GetContainer()->setWebLayer(enable ? web_layer_.get() : NULL);
 142   } else if (frame_) {
 143     frame_->setRemoteWebLayer(enable ? web_layer_.get() : NULL);
 144   }
 145 }
 146
 147 void ChildFrameCompositingHelper::CheckSizeAndAdjustLayerProperties(
 148     const gfx::Size& new_size,
 149     float device_scale_factor,
 150     cc::Layer* layer) {
 151   if (buffer_size_ != new_size) {
 152     buffer_size_ = new_size;
 153     // The container size is in DIP, so is the layer size.
 154     // Buffer size is in physical pixels, so we need to adjust
 155     // it by the device scale factor.
 156     gfx::Size device_scale_adjusted_size = gfx::ToFlooredSize(
 157         gfx::ScaleSize(buffer_size_, 1.0f / device_scale_factor));
 158     layer->SetBounds(device_scale_adjusted_size);
 159   }
 160
 161   // Manually manage background layer for transparent webview.
 162   if (!opaque_)
 163     background_layer_->SetIsDrawable(false);
 164 }
 165
 166 void ChildFrameCompositingHelper::OnContainerDestroy() {
 167   if (GetContainer())
 168     GetContainer()->setWebLayer(NULL);
 169
 170   if (resource_collection_.get())
 171     resource_collection_->SetClient(NULL);
 172
 173   ack_pending_ = false;
 174   resource_collection_ = NULL;
 175   frame_provider_ = NULL;
 176   delegated_layer_ = NULL;
 177   background_layer_ = NULL;
 178   web_layer_.reset();
 179 }
 180
 181 void ChildFrameCompositingHelper::ChildFrameGone() {
 182   background_layer_->SetBackgroundColor(SkColorSetARGBInline(255, 0, 128, 0));
 183   background_layer_->RemoveAllChildren();
 184   background_layer_->SetIsDrawable(true);
 185   background_layer_->SetContentsOpaque(true);
 186 }
 187
 188 void ChildFrameCompositingHelper::OnCompositorFrameSwapped(
 189     scoped_ptr<cc::CompositorFrame> frame,
 190     int route_id,
 191     uint32 output_surface_id,
 192     int host_id,
 193     base::SharedMemoryHandle handle) {
 194   cc::DelegatedFrameData* frame_data = frame->delegated_frame_data.get();
 195   // Do nothing if we are getting destroyed or have no frame data.
 196   if (!frame_data || !background_layer_.get())
 197     return;
 198
 199   DCHECK(!frame_data->render_pass_list.empty());
 200   cc::RenderPass* root_pass = frame_data->render_pass_list.back();
 201   gfx::Size frame_size = root_pass->output_rect.size();
 202
 203   if (last_route_id_ != route_id ||
 204       last_output_surface_id_ != output_surface_id ||
 205       last_host_id_ != host_id) {
 206     // Resource ids are scoped by the output surface.
 207     // If the originating output surface doesn't match the last one, it
 208     // indicates the guest's output surface may have been recreated, in which
 209     // case we should recreate the DelegatedRendererLayer, to avoid matching
 210     // resources from the old one with resources from the new one which would
 211     // have the same id.
 212     frame_provider_ = NULL;
 213
 214     // Drop the cc::DelegatedFrameResourceCollection so that we will not return
 215     // any resources from the old output surface with the new output surface id.
 216     if (resource_collection_.get()) {
 217       resource_collection_->SetClient(NULL);
 218
 219       if (resource_collection_->LoseAllResources())
 220         SendReturnedDelegatedResources();
 221       resource_collection_ = NULL;
 222     }
 223     last_output_surface_id_ = output_surface_id;
 224     last_route_id_ = route_id;
 225     last_host_id_ = host_id;
 226   }
 227   if (!resource_collection_.get()) {
 228     resource_collection_ = new cc::DelegatedFrameResourceCollection;
 229     resource_collection_->SetClient(this);
 230   }
 231   if (!frame_provider_.get() || frame_provider_->frame_size() != frame_size) {
 232     frame_provider_ = new cc::DelegatedFrameProvider(
 233         resource_collection_.get(), frame->delegated_frame_data.Pass());
 234     if (delegated_layer_.get())
 235       delegated_layer_->RemoveFromParent();
 236     delegated_layer_ =
 237         cc::DelegatedRendererLayer::Create(frame_provider_.get());
 238     delegated_layer_->SetIsDrawable(true);
 239     buffer_size_ = gfx::Size();
 240     SetContentsOpaque(opaque_);
 241     background_layer_->AddChild(delegated_layer_);
 242   } else {
 243     frame_provider_->SetFrameData(frame->delegated_frame_data.Pass());
 244   }
 245
 246   CheckSizeAndAdjustLayerProperties(
 247       frame_data->render_pass_list.back()->output_rect.size(),
 248       frame->metadata.device_scale_factor,
 249       delegated_layer_.get());
 250
 251   ack_pending_ = true;
 252 }
 253
 254 void ChildFrameCompositingHelper::UpdateVisibility(bool visible) {
 255   if (delegated_layer_.get())
 256     delegated_layer_->SetIsDrawable(visible);
 257 }
 258
 259 void ChildFrameCompositingHelper::UnusedResourcesAreAvailable() {
 260   if (ack_pending_)
 261     return;
 262
 263   SendReturnedDelegatedResources();
 264 }
 265
 266 void ChildFrameCompositingHelper::SendReturnedDelegatedResources() {
 267   FrameHostMsg_ReclaimCompositorResources_Params params;
 268   if (resource_collection_.get())
 269     resource_collection_->TakeUnusedResourcesForChildCompositor(
 270         &params.ack.resources);
 271   DCHECK(!params.ack.resources.empty());
 272
 273   params.route_id = last_route_id_;
 274   params.output_surface_id = last_output_surface_id_;
 275   params.renderer_host_id = last_host_id_;
 276   SendReclaimCompositorResourcesToBrowser(params);
 277 }
 278
 279 void ChildFrameCompositingHelper::SetContentsOpaque(bool opaque) {
 280   opaque_ = opaque;
 281   if (delegated_layer_.get())
 282     delegated_layer_->SetContentsOpaque(opaque_);
 283 }
 284
 285 }  // namespace content