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

content/browser/renderer_host/render_widget_host_view_aura.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 "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 1281 matching lines @@
     cc::TextureMailbox mailbox;
     scoped_ptr<cc::SingleReleaseCallback> callback;
     framebuffer_holder_->GetMailbox(&mailbox, &callback);
     window_->layer()->SetTextureMailbox(mailbox,
                                         callback.Pass(),
                                         last_swapped_surface_scale_factor_);
     current_frame_size_ = ConvertSizeToDIP(last_swapped_surface_scale_factor_,
                                            mailbox.shared_memory_size());
     CheckResizeLock();
   } else {
-    window_->layer()->SetExternalTexture(NULL);
+    window_->layer()->SetShowPaintedContent();
     resize_lock_.reset();
     host_->WasResized();
     framebuffer_holder_ = NULL;
     FrameMemoryManager::GetInstance()->RemoveFrame(this);
   }
 }
 
 bool RenderWidgetHostViewAura::SwapBuffersPrepare(
     const gfx::Rect& surface_rect,
     float surface_scale_factor,
@@ skipping 110 matching lines @@
 void RenderWidgetHostViewAura::SwapDelegatedFrame(
     uint32 output_surface_id,
     scoped_ptr<cc::DelegatedFrameData> frame_data,
     float frame_device_scale_factor,
     const ui::LatencyInfo& latency_info) {
   gfx::Size frame_size;
   gfx::Size frame_size_in_dip;
   gfx::Rect damage_rect;
   gfx::Rect damage_rect_in_dip;
 
-  if (!frame_data->render_pass_list.empty()) {
+  bool has_content = !frame_data->render_pass_list.empty();
+  if (has_content) {
     cc::RenderPass* root_pass = frame_data->render_pass_list.back();
 
     frame_size = root_pass->output_rect.size();
     frame_size_in_dip = ConvertSizeToDIP(frame_device_scale_factor, frame_size);
 
     damage_rect = gfx::ToEnclosingRect(root_pass->damage_rect);
     damage_rect.Intersect(gfx::Rect(frame_size));
     damage_rect_in_dip = ConvertRectToDIP(frame_device_scale_factor,
                                           damage_rect);
   }
@@ skipping 21 matching lines @@
     cc::RenderPass* root_pass = frame_data->render_pass_list.back();
     root_pass->damage_rect = damage_rect;
   }
 
   if (output_surface_id != last_output_surface_id_) {
     // Resource ids are scoped by the output surface.
     // If the originating output surface doesn't match the last one, it
     // indicates the renderer's output surface may have been recreated, in which
     // case we should recreate the DelegatedRendererLayer, to avoid matching
     // resources from the old one with resources from the new one which would
-    // have the same id.
-    window_->layer()->SetDelegatedFrame(scoped_ptr<cc::DelegatedFrameData>(),
-                                        frame_size_in_dip);
+    // have the same id. Changing the layer to showing painted content destroys
+    // the DelegatedRendererLayer.
+    window_->layer()->SetShowPaintedContent();
     last_output_surface_id_ = output_surface_id;
   }
-  window_->layer()->SetDelegatedFrame(frame_data.Pass(), frame_size_in_dip);
+  if (has_content)
+    window_->layer()->SetDelegatedFrame(frame_data.Pass(), frame_size_in_dip);
+  else
+    window_->layer()->SetShowPaintedContent();
   released_front_lock_ = NULL;
   current_frame_size_ = frame_size_in_dip;
   CheckResizeLock();
 
   if (paint_observer_)
     paint_observer_->OnUpdateCompositorContent();
   window_->SchedulePaintInRect(damage_rect_in_dip);
 
   ui::Compositor* compositor = GetCompositor();
   if (!compositor) {
@@ skipping 1094 matching lines @@
         gl_helper && current_surface_.get()) {
       WebKit::WebGLId texture_id =
           gl_helper->CopyTexture(current_surface_->PrepareTexture(),
                                  current_surface_->size());
       if (texture_id) {
         new_texture = factory->CreateOwnedTexture(
           current_surface_->size(),
           current_surface_->device_scale_factor(), texture_id);
       }
     }
-    old_layer->SetExternalTexture(new_texture);
-    new_layer->SetExternalTexture(old_texture);
+    if (new_texture.get())
+      old_layer->SetExternalTexture(new_texture.get());
+    else
+      old_layer->SetShowPaintedContent();
+    new_layer->SetExternalTexture(old_texture.get());
   } else if (old_mailbox.IsSharedMemory()) {
     base::SharedMemory* old_buffer = old_mailbox.shared_memory();
     const size_t size = old_mailbox.shared_memory_size_in_bytes();
 
     scoped_ptr<base::SharedMemory> new_buffer(new base::SharedMemory);
     new_buffer->CreateAndMapAnonymous(size);
 
     if (old_buffer->memory() && new_buffer->memory()) {
       memcpy(new_buffer->memory(), old_buffer->memory(), size);
       base::SharedMemory* new_buffer_raw_ptr = new_buffer.get();
@@ skipping 734 matching lines @@
       aura::client::GetCursorClient(window_->GetRootWindow());
   if (cursor_client)
     cursor_client->RemoveObserver(this);
 
   event_filter_for_popup_exit_.reset();
   window_->GetRootWindow()->RemoveRootWindowObserver(this);
   host_->ParentChanged(0);
   ui::Compositor* compositor = GetCompositor();
   // We can't get notification for commits after this point, which would
   // guarantee that the compositor isn't using an old texture any more, so
-  // instead we force the texture to NULL which synchronizes with the compositor
-  // thread, and makes it safe to run the callback.
-  window_->layer()->SetExternalTexture(NULL);
+  // instead we force the layer to stop using any external resources which
+  // synchronizes with the compositor thread, and makes it safe to run the
+  // callback.
+  window_->layer()->SetShowPaintedContent();
   RunOnCommitCallbacks();
   resize_lock_.reset();
   host_->WasResized();
   if (compositor && compositor->HasObserver(this))
     compositor->RemoveObserver(this);
 }
 
 ui::Compositor* RenderWidgetHostViewAura::GetCompositor() const {
   aura::RootWindow* root_window = window_->GetRootWindow();
   return root_window ? root_window->compositor() : NULL;
@@ skipping 13 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content