aura: Use Layer::SetShowPaintedContent to stop showing external content

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 458 matching lines @@
   cc_layer_->SetHideLayerAndSubtree(!visible_);
 }
 
 void Layer::SwitchCCLayerForTest() {
   scoped_refptr<cc::ContentLayer> new_layer = cc::ContentLayer::Create(this);
   SwitchToLayer(new_layer);
   content_layer_ = new_layer;
 }
 
 void Layer::SetExternalTexture(Texture* texture) {
+  DCHECK(texture);
+
   // Hold a ref to the old |Texture| until we have updated all
   // compositor references to the texture id that it holds.
   scoped_refptr<ui::Texture> old_texture = texture_;
 
   DCHECK_EQ(type_, LAYER_TEXTURED);
   DCHECK(!solid_color_layer_.get());
-  bool has_texture = !!texture;
-  layer_updated_externally_ = has_texture;
+  layer_updated_externally_ = true;
   texture_ = texture;
-  if (!!texture_layer_.get() != has_texture) {
-    // Switch to a different type of layer.
-    if (has_texture) {
-      scoped_refptr<cc::TextureLayer> new_layer =
-          cc::TextureLayer::Create(this);
-      new_layer->SetFlipped(texture_->flipped());
-      SwitchToLayer(new_layer);
-      texture_layer_ = new_layer;
-    } else {
-      scoped_refptr<cc::ContentLayer> new_layer =
-          cc::ContentLayer::Create(this);
-      SwitchToLayer(new_layer);
-      content_layer_ = new_layer;
-      mailbox_ = cc::TextureMailbox();
-    }
+  if (!texture_layer_.get()) {
+    scoped_refptr<cc::TextureLayer> new_layer = cc::TextureLayer::Create(this);
+    new_layer->SetFlipped(texture_->flipped());
+    SwitchToLayer(new_layer);
+    texture_layer_ = new_layer;
   }
   RecomputeDrawsContentAndUVRect();
 }
 
 void Layer::SetTextureMailbox(
     const cc::TextureMailbox& mailbox,
     scoped_ptr<cc::SingleReleaseCallback> release_callback,
     float scale_factor) {
   DCHECK_EQ(type_, LAYER_TEXTURED);
   DCHECK(!solid_color_layer_.get());
@@ skipping 13 matching lines @@
 }
 
 cc::TextureMailbox Layer::GetTextureMailbox(float* scale_factor) {
   if (scale_factor)
     *scale_factor = mailbox_scale_factor_;
   return mailbox_;
 }
 
 void Layer::SetDelegatedFrame(scoped_ptr<cc::DelegatedFrameData> frame,
                               gfx::Size frame_size_in_dip) {
+  DCHECK(frame && !frame->render_pass_list.empty());
+
   DCHECK_EQ(type_, LAYER_TEXTURED);
-  bool has_frame = frame.get() && !frame->render_pass_list.empty();
-  layer_updated_externally_ = has_frame;
+  layer_updated_externally_ = true;
   delegated_frame_size_in_dip_ = frame_size_in_dip;
-  if (!!delegated_renderer_layer_.get() != has_frame) {
-    if (has_frame) {
-      scoped_refptr<cc::DelegatedRendererLayer> new_layer =
-          cc::DelegatedRendererLayer::Create(NULL);
-      SwitchToLayer(new_layer);
-      delegated_renderer_layer_ = new_layer;
-    } else {
-      scoped_refptr<cc::ContentLayer> new_layer =
-          cc::ContentLayer::Create(this);
-      SwitchToLayer(new_layer);
-      content_layer_ = new_layer;
-    }
+  if (!delegated_renderer_layer_.get()) {
+    scoped_refptr<cc::DelegatedRendererLayer> new_layer =
+        cc::DelegatedRendererLayer::Create(NULL);
+    SwitchToLayer(new_layer);
+    delegated_renderer_layer_ = new_layer;
   }
-  if (has_frame)
-    delegated_renderer_layer_->SetFrameData(frame.Pass());
+  delegated_renderer_layer_->SetFrameData(frame.Pass());
   RecomputeDrawsContentAndUVRect();
 }
 
 void Layer::TakeUnusedResourcesForChildCompositor(
     cc::ReturnedResourceArray* list) {
   if (delegated_renderer_layer_.get())
     delegated_renderer_layer_->TakeUnusedResourcesForChildCompositor(list);
 }
 
-void Layer::SetColor(SkColor color) {
-  GetAnimator()->SetColor(color);
+void Layer::SetShowPaintedContent() {
+  if (content_layer_.get())
+    return;
+
+  // Hold a ref to the old |texture_| until we have updated all
+  // compositor references to the texture id that it holds.
+  scoped_refptr<ui::Texture> old_texture = texture_;

[piman, 2013/10/01 21:21:45]

nit: I don't think that's necessary in this function. It's needed in the
SetExternalTexture case because we reset texture_ before we cleaned up the layer
in SwitchToLayer, but in this case, we SwitchToLayer first, so we already keep
the reference in texture_ correctly.

[danakj, 2013/10/01 22:37:19]

Done.

+
+  layer_updated_externally_ = false;
+
+  scoped_refptr<cc::ContentLayer> new_layer = cc::ContentLayer::Create(this);
+  SwitchToLayer(new_layer);
+  content_layer_ = new_layer;
+
+  mailbox_ = cc::TextureMailbox();
+  texture_ = NULL;
+
+  RecomputeDrawsContentAndUVRect();
 }
 
+void Layer::SetColor(SkColor color) { GetAnimator()->SetColor(color); }
+
 bool Layer::SchedulePaint(const gfx::Rect& invalid_rect) {
   if (type_ == LAYER_SOLID_COLOR || (!delegate_ && !texture_.get()))
     return false;
 
   damaged_region_.op(invalid_rect.x(),
                      invalid_rect.y(),
                      invalid_rect.right(),
                      invalid_rect.bottom(),
                      SkRegion::kUnion_Op);
   ScheduleDraw();
@@ skipping 397 matching lines @@
   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