Move the content-dependent RecreateLayer logic from aura::Window to RWHVA

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 101 matching lines @@
   friend class base::RefCounted<MemoryHolder>;
   ~MemoryHolder() { callback_.Run(); }
 
   scoped_ptr<base::SharedMemory> shared_memory_;
   gfx::Size frame_size_;
   base::Callback<void()> callback_;
 };
 
 namespace {
 
+void MailboxReleaseCallback(scoped_ptr<base::SharedMemory> shared_memory,
+                            unsigned sync_point, bool lost_resource) {
+  // NOTE: shared_memory will get released when we go out of scope.
+}
+
 // In mouse lock mode, we need to prevent the (invisible) cursor from hitting
 // the border of the view, in order to get valid movement information. However,
 // forcing the cursor back to the center of the view after each mouse move
 // doesn't work well. It reduces the frequency of useful mouse move messages
 // significantly. Therefore, we move the cursor to the center of the view only
 // if it approaches the border. |kMouseLockBorderPercentage| specifies the width
 // of the border area, in percentage of the corresponding dimension.
 const int kMouseLockBorderPercentage = 15;
 
 // When accelerated compositing is enabled and a widget resize is pending,
@@ skipping 2352 matching lines @@
 void RenderWidgetHostViewAura::OnWindowTargetVisibilityChanged(bool visible) {
 }
 
 bool RenderWidgetHostViewAura::HasHitTestMask() const {
   return false;
 }
 
 void RenderWidgetHostViewAura::GetHitTestMask(gfx::Path* mask) const {
 }
 
-scoped_refptr<ui::Texture> RenderWidgetHostViewAura::CopyTexture() {
-  if (!host_->is_accelerated_compositing_active())
-    return scoped_refptr<ui::Texture>();
+void RenderWidgetHostViewAura::DidRecreateLayer(ui::Layer *old_layer,
+                                                ui::Layer *new_layer) {
+  float mailbox_scale_factor;
+  cc::TextureMailbox old_mailbox =
+      old_layer->GetTextureMailbox(&mailbox_scale_factor);
+  scoped_refptr<ui::Texture> old_texture = old_layer->external_texture();
+  // The new_layer is the one that will be used by our Window, so that's the one
+  // that should keep our texture. old_layer will be returned to the
+  // RecreateLayer caller, and should have a copy.
+  if (old_texture.get()) {
+    ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
+    GLHelper* gl_helper = factory->GetGLHelper();
+    scoped_refptr<ui::Texture> new_texture;
+    if (host_->is_accelerated_compositing_active() &&
+        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);
+  } else if (old_mailbox.IsSharedMemory()) {
+    base::SharedMemory* old_buffer = old_mailbox.shared_memory();
+    const size_t size = old_mailbox.shared_memory_size_in_bytes();
 
-  ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
-  GLHelper* gl_helper = factory->GetGLHelper();
-  if (!gl_helper)
-    return scoped_refptr<ui::Texture>();
+    scoped_ptr<base::SharedMemory> new_buffer(new base::SharedMemory);
+    new_buffer->CreateAndMapAnonymous(size);
 
-  if (!current_surface_.get())
-    return scoped_refptr<ui::Texture>();
-
-  WebKit::WebGLId texture_id =
-      gl_helper->CopyTexture(current_surface_->PrepareTexture(),
-                             current_surface_->size());
-  if (!texture_id)
-    return scoped_refptr<ui::Texture>();
-
-  return scoped_refptr<ui::Texture>(
-      factory->CreateOwnedTexture(
-          current_surface_->size(),
-          current_surface_->device_scale_factor(), texture_id));
+    if (old_buffer->memory() && new_buffer->memory()) {
+      memcpy(new_buffer->memory(), old_buffer->memory(), size);
+      base::SharedMemory* new_buffer_raw_ptr = new_buffer.get();
+      cc::TextureMailbox::ReleaseCallback callback =
+          base::Bind(MailboxReleaseCallback, Passed(&new_buffer));
+      cc::TextureMailbox new_mailbox(new_buffer_raw_ptr,
+                                     old_mailbox.shared_memory_size(),
+                                     callback);
+      new_layer->SetTextureMailbox(new_mailbox, mailbox_scale_factor);
+    }
+  }
+  // TODO(piman): handle delegated frames.
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ui::EventHandler implementation:
 
 void RenderWidgetHostViewAura::OnKeyEvent(ui::KeyEvent* event) {
   TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnKeyEvent");
   if (touch_editing_client_ && touch_editing_client_->HandleInputEvent(event))
     return;
 
@@ skipping 743 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content