[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/public/platform/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 93 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.IsSharedMemory() ||

[piman, 2013/06/07 01:26:28]

In which case do you need to call SetTextureMailbox with the same shared memory?
Are you sure those cases are properly handled by the corresponding callback?

That's the reason this DCHECK exists for the texture case - it's not that it
can't be handled through cc, it's that most likely it is not correctly handled
by the caller side (it's indeed not trivial to do so without refcounting and
other things).

[slavi, 2013/06/07 21:49:21]

This check was failing after tab detach/reattach. Changed it to only check if
it's the owner of the mailbox.

[piman, 2013/06/07 23:29:59]

What this means is that detaching/reattaching a tab will draw blank until you
receive a new frame from the renderer. We'll need to fix that. Can you file a
bug?

+         !mailbox.ContainsMailbox(texture_mailbox_.name()));
   // 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;
   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_ || texture_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))
+      if (client_->PrepareTextureMailbox(&mailbox)) {
+        if (mailbox.IsTexture())
+          DCHECK(client_->Context3d());
         SetTextureMailbox(mailbox);
+      }
     } else {
+      DCHECK(client_->Context3d());
       texture_id_ = client_->PrepareTexture(queue);
     }
-    context_lost_ =
+    context_lost_ = client_->Context3d() &&
         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, texture_mailbox_.callback());
+    texture_layer->SetTextureMailbox(
+        texture_mailbox_.CopyWithNewCallback(callback));
     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