[Aura] Added Support for rendering software compositor frames as cc::TextureLayers.

ui/compositor/layer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 68 matching lines @@
       background_blur_radius_(0),
       layer_saturation_(0.0f),
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
       layer_inverted_(false),
       layer_mask_(NULL),
       layer_mask_back_link_(NULL),
       zoom_(1),
       zoom_inset_(0),
       delegate_(NULL),
+      cc_layer_(NULL),
       scale_content_(true),
       device_scale_factor_(1.0f) {
   CreateWebLayer();
 }
 
 Layer::~Layer() {
   // Destroying the animator may cause observers to use the layer (and
   // indirectly the WebLayer). Destroy the animator first so that the WebLayer
   // is still around.
   if (animator_)
@@ skipping 408 matching lines @@
     } else {
       scoped_refptr<cc::ContentLayer> new_layer =
           cc::ContentLayer::Create(this);
       SwitchToLayer(new_layer);
       content_layer_ = new_layer;
     }
   }
   RecomputeDrawsContentAndUVRect();
 }
 
+void Layer::SetTextureMailbox(const cc::TextureMailbox& mailbox,
+                              float scale_factor) {
+  DCHECK_EQ(type_, LAYER_TEXTURED);
+  DCHECK(!solid_color_layer_);
+  layer_updated_externally_ = true;
+  texture_ = NULL;
+  if (!texture_layer_ || !texture_layer_->uses_mailbox()) {
+    scoped_refptr<cc::TextureLayer> new_layer =
+        cc::TextureLayer::CreateForMailbox(this);
+    new_layer->SetFlipped(false);
+    SwitchToLayer(new_layer);
+    texture_layer_ = new_layer;
+  }
+  texture_layer_->SetTextureMailbox(mailbox);
+  mailbox_ = mailbox;
+  mailbox_scale_factor_ = scale_factor;
+  RecomputeDrawsContentAndUVRect();
+}
+
+cc::TextureMailbox Layer::GetTextureMailbox(float* scale_factor) {
+  if (scale_factor)
+    *scale_factor = mailbox_scale_factor_;
+  cc::TextureMailbox::ReleaseCallback callback;
+  return mailbox_.CopyWithNewCallback(callback);
+}
+
 void Layer::SetDelegatedFrame(scoped_ptr<cc::DelegatedFrameData> frame,
                               gfx::Size frame_size_in_dip) {
   DCHECK_EQ(type_, LAYER_TEXTURED);
   bool has_frame = frame.get() && !frame->render_pass_list.empty();
   layer_updated_externally_ = has_frame;
   delegated_frame_size_in_dip_ = frame_size_in_dip;
   if (!!delegated_renderer_layer_ != has_frame) {
     if (has_frame) {
       scoped_refptr<cc::DelegatedRendererLayer> new_layer =
           cc::DelegatedRendererLayer::Create(NULL);
@@ skipping 102 matching lines @@
   }
 
   if (delegate_)
     delegate_->OnPaintLayer(canvas.get());
   if (scale_content)
     canvas->Restore();
 }
 
 unsigned Layer::PrepareTexture(cc::ResourceUpdateQueue* queue) {
   DCHECK(texture_layer_);
-  return texture_->PrepareTexture();
+  if (texture_)
+    return texture_->PrepareTexture();
+  return 0;
 }
 
 WebKit::WebGraphicsContext3D* Layer::Context3d() {
   DCHECK(texture_layer_);
-  return texture_->HostContext3D();
+  if (texture_)
+    return texture_->HostContext3D();
+  return NULL;
 }
 
 bool Layer::PrepareTextureMailbox(cc::TextureMailbox* mailbox) {
   return false;
 }
 
 void Layer::SetForceRenderSurface(bool force) {
   if (force_render_surface_ == force)
     return;
 
@@ skipping 257 matching lines @@
   transform.Scale(1.0f / device_scale_factor_, 1.0f / device_scale_factor_);
   transform.PreconcatTransform(cc_layer_->transform());
   transform.Scale(device_scale_factor_, device_scale_factor_);
   return transform;
 }
 
 void Layer::RecomputeDrawsContentAndUVRect() {
   DCHECK(cc_layer_);
   gfx::Size size(bounds_.size());
   if (texture_layer_.get()) {
-    DCHECK(texture_);
-
-    float texture_scale_factor = 1.0f / texture_->device_scale_factor();
-    gfx::Size texture_size = gfx::ToFlooredSize(
-        gfx::ScaleSize(texture_->size(), texture_scale_factor));
+    gfx::Size texture_size;
+    if (!texture_layer_->uses_mailbox()) {
+      DCHECK(texture_);
+      float texture_scale_factor = 1.0f / texture_->device_scale_factor();
+      texture_size = gfx::ToFlooredSize(
+          gfx::ScaleSize(texture_->size(), texture_scale_factor));
+    } else {
+      DCHECK(mailbox_.IsSharedMemory());
+      float texture_scale_factor = 1.0f / mailbox_scale_factor_;
+      texture_size = gfx::ToFlooredSize(
+          gfx::ScaleSize(mailbox_.shared_memory_size(), texture_scale_factor));
+    }
     size.ClampToMax(texture_size);
 
     gfx::PointF uv_top_left(0.f, 0.f);
     gfx::PointF uv_bottom_right(
         static_cast<float>(size.width())/texture_size.width(),
         static_cast<float>(size.height())/texture_size.height());
     texture_layer_->SetUV(uv_top_left, uv_bottom_right);
   } else if (delegated_renderer_layer_.get()) {
     delegated_renderer_layer_->SetDisplaySize(
         ConvertSizeToPixel(this, delegated_frame_size_in_dip_));
     size.ClampToMax(delegated_frame_size_in_dip_);
   }
   cc_layer_->SetBounds(ConvertSizeToPixel(this, size));
 }
 
 void Layer::RecomputePosition() {
   cc_layer_->SetPosition(gfx::ScalePoint(
         gfx::PointF(bounds_.x(), bounds_.y()),
         device_scale_factor_));
 }
 
 }  // namespace ui