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

cc/layers/texture_layer.cc

 // Copyright 2010 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 "cc/layers/texture_layer.h"
 
 #include "cc/base/thread.h"
 #include "cc/layers/texture_layer_client.h"
 #include "cc/layers/texture_layer_impl.h"
 #include "cc/trees/layer_tree_host.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
 
 namespace cc {
 
-static void RunCallbackOnMainThread(
+namespace {
+
+void RunCallback(
     const TextureMailbox::ReleaseCallback& callback,
     unsigned sync_point,
     bool lost_resource) {
   callback.Run(sync_point, lost_resource);
 }
 
-static void PostCallbackToMainThread(
-    Thread* main_thread,
+void PostCallbackToThread(
+    Thread* thread,
     const TextureMailbox::ReleaseCallback& callback,
     unsigned sync_point,
     bool lost_resource) {
-  main_thread->PostTask(base::Bind(&RunCallbackOnMainThread,
-                                   callback,
-                                   sync_point,
-                                   lost_resource));
+  if (!callback.is_null())
+    thread->PostTask(base::Bind(&RunCallback, callback,
+                                sync_point, lost_resource));
 }
 
+}  // namespace
+
 scoped_refptr<TextureLayer> TextureLayer::Create(TextureLayerClient* client) {
   return scoped_refptr<TextureLayer>(new TextureLayer(client, false));
 }
 
 scoped_refptr<TextureLayer> TextureLayer::CreateForMailbox(
     TextureLayerClient* client) {
   return scoped_refptr<TextureLayer>(new TextureLayer(client, true));
 }
 
 TextureLayer::TextureLayer(TextureLayerClient* client, bool uses_mailbox)
@@ skipping 16 matching lines @@
 }
 
 TextureLayer::~TextureLayer() {
   if (layer_tree_host()) {
     if (texture_id_)
       layer_tree_host()->AcquireLayerTextures();
     if (rate_limit_context_ && client_)
       layer_tree_host()->StopRateLimiter(client_->Context3d());
   }
   if (own_mailbox_)
-    texture_mailbox_.RunReleaseCallback(texture_mailbox_.sync_point(), false);
+    mailbox_.RunReleaseCallback(mailbox_.sync_point(), false);
 }
 
 void TextureLayer::ClearClient() {
   client_ = NULL;
   if (uses_mailbox_)
     SetTextureMailbox(TextureMailbox());
   else
     SetTextureId(0);
 }
 
@@ skipping 56 matching lines @@
   if (texture_id_ == id)
     return;
   if (texture_id_ && layer_tree_host())
     layer_tree_host()->AcquireLayerTextures();
   texture_id_ = id;
   SetNeedsCommit();
 }
 
 void TextureLayer::SetTextureMailbox(const TextureMailbox& mailbox) {
   DCHECK(uses_mailbox_);
-  DCHECK(mailbox.IsEmpty() || !mailbox.Equals(texture_mailbox_));
+  DCHECK(!mailbox.IsValid() || !mailbox.Equals(mailbox_));
   // If we never commited the mailbox, we need to release it here
   if (own_mailbox_)
-    texture_mailbox_.RunReleaseCallback(texture_mailbox_.sync_point(), false);
-  texture_mailbox_ = mailbox;
+    mailbox_.RunReleaseCallback(mailbox_.sync_point(), false);
+  mailbox_ = mailbox;
   own_mailbox_ = true;
-
   SetNeedsCommit();
 }
 
 void TextureLayer::WillModifyTexture() {
   if (layer_tree_host() && (DrawsContent() || content_committed_)) {
     layer_tree_host()->AcquireLayerTextures();
     content_committed_ = false;
   }
 }
 
 void TextureLayer::SetNeedsDisplayRect(const gfx::RectF& dirty_rect) {
   Layer::SetNeedsDisplayRect(dirty_rect);
 
   if (rate_limit_context_ && client_ && layer_tree_host() && DrawsContent())
     layer_tree_host()->StartRateLimiter(client_->Context3d());
 }
 
 void TextureLayer::SetLayerTreeHost(LayerTreeHost* host) {
   if (texture_id_ && layer_tree_host() && host != layer_tree_host())
     layer_tree_host()->AcquireLayerTextures();
   Layer::SetLayerTreeHost(host);
 }
 
 bool TextureLayer::DrawsContent() const {
-  return (client_ || texture_id_ || !texture_mailbox_.IsEmpty()) &&
+  return (client_ || texture_id_ || mailbox_.IsValid()) &&
          !context_lost_ && Layer::DrawsContent();
 }
 
 void TextureLayer::Update(ResourceUpdateQueue* queue,
                           const OcclusionTracker* occlusion,
                           RenderingStats* stats) {
   if (client_) {
     if (uses_mailbox_) {
       TextureMailbox mailbox;
       if (client_->PrepareTextureMailbox(&mailbox))
         SetTextureMailbox(mailbox);
     } else {
       texture_id_ = client_->PrepareTexture(queue);
     }
-    context_lost_ =
+    context_lost_ = client_->Context3d() &&

[danakj, 2013/05/23 15:34:32]

Can you DCHECK that Context3d() is not NULL when the texture_mailbox_
IsTexture()?

[slavi, 2013/05/28 18:55:13]

Done.

         client_->Context3d()->getGraphicsResetStatusARB() != GL_NO_ERROR;
   }
 
   needs_display_ = false;
 }
 
 void TextureLayer::PushPropertiesTo(LayerImpl* layer) {
   Layer::PushPropertiesTo(layer);
 
   TextureLayerImpl* texture_layer = static_cast<TextureLayerImpl*>(layer);
   texture_layer->set_flipped(flipped_);
   texture_layer->set_uv_top_left(uv_top_left_);
   texture_layer->set_uv_bottom_right(uv_bottom_right_);
   texture_layer->set_vertex_opacity(vertex_opacity_);
   texture_layer->set_premultiplied_alpha(premultiplied_alpha_);
   if (uses_mailbox_ && own_mailbox_) {
     Thread* main_thread = layer_tree_host()->proxy()->MainThread();
-    TextureMailbox::ReleaseCallback callback;
-    if (!texture_mailbox_.IsEmpty())
-      callback = base::Bind(
-          &PostCallbackToMainThread, main_thread, texture_mailbox_.callback());
-    texture_layer->SetTextureMailbox(TextureMailbox(
-        texture_mailbox_.name(), callback, texture_mailbox_.sync_point()));
+    TextureMailbox::ReleaseCallback callback = base::Bind(
+        &PostCallbackToThread, main_thread, mailbox_.callback());
+    if (mailbox_.IsTexture()) {
+      texture_layer->SetTextureMailbox(TextureMailbox(
+          mailbox_.name(), callback, mailbox_.sync_point()));
+    } else if (mailbox_.IsSharedMemory()) {
+      texture_layer->SetTextureMailbox(TextureMailbox(
+          mailbox_.handle(), mailbox_.size(), callback));
+    } else {
+      texture_layer->SetTextureMailbox(TextureMailbox());

[danakj, 2013/05/23 15:34:33]

DCHECK that the texture_mailbox_ is not valid?

[slavi, 2013/05/28 18:55:13]

Done.

+    }
     own_mailbox_ = false;
   } else {
     texture_layer->set_texture_id(texture_id_);
   }
   content_committed_ = DrawsContent();
 }
 
 bool TextureLayer::BlocksPendingCommit() const {
   // Double-buffered texture layers need to be blocked until they can be made
   // triple-buffered.  Single-buffered layers already prevent draws, so
   // can block too for simplicity.
   return DrawsContent();
 }
 
 bool TextureLayer::CanClipSelf() const {
   return true;
 }
 
 }  // namespace cc