Make software compositing work on Mac.

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 75 matching lines @@
 #endif
 
 using gfx::RectToSkIRect;
 using gfx::SkIRectToRect;
 
 using WebKit::WebScreenInfo;
 using WebKit::WebTouchEvent;
 
 namespace content {
 
-void ReleaseMailbox(scoped_refptr<MemoryHolder> holder,
-                    unsigned sync_point,
-                    bool lost_resource) {}
-
-class MemoryHolder : public base::RefCounted<MemoryHolder> {
- public:
-  MemoryHolder(scoped_ptr<base::SharedMemory> shared_memory,
-               gfx::Size frame_size,
-               base::Callback<void()> callback)
-      : shared_memory_(shared_memory.Pass()),
-        frame_size_(frame_size),
-        callback_(callback) {}
-
-  void GetMailbox(cc::TextureMailbox* mailbox,
-                  scoped_ptr<cc::SingleReleaseCallback>* release_callback) {
-    *mailbox = cc::TextureMailbox(shared_memory_.get(), frame_size_);
-    *release_callback = cc::SingleReleaseCallback::Create(
-        base::Bind(ReleaseMailbox, make_scoped_refptr(this)));
-  }
-
- private:
-  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
@@ skipping 461 matching lines @@
       last_output_surface_id_(0),
       pending_delegated_ack_count_(0),
       skipped_frames_(false),
       last_swapped_surface_scale_factor_(1.f),
       paint_canvas_(NULL),
       synthetic_move_sent_(false),
       accelerated_compositing_state_changed_(false),
       can_lock_compositor_(YES),
       cursor_visibility_state_in_renderer_(UNKNOWN),
       paint_observer_(NULL),
-      touch_editing_client_(NULL) {
+      touch_editing_client_(NULL),
+      weak_ptr_factory_(this) {
   host_->SetView(this);
   window_observer_.reset(new WindowObserver(this));
   aura::client::SetTooltipText(window_, &tooltip_);
   aura::client::SetActivationDelegate(window_, this);
   aura::client::SetActivationChangeObserver(window_, this);
   aura::client::SetFocusChangeObserver(window_, this);
   gfx::Screen::GetScreenFor(window_)->AddObserver(this);
 #if defined(OS_WIN)
   transient_observer_.reset(new TransientWindowObserver(this));
 #endif
+  software_frame_manager_.reset(new SoftwareFrameManager(
+      weak_ptr_factory_.GetWeakPtr()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, RenderWidgetHostView implementation:
 
 void RenderWidgetHostViewAura::InitAsChild(
     gfx::NativeView parent_view) {
   window_->Init(ui::LAYER_TEXTURED);
   window_->SetName("RenderWidgetHostViewAura");
 }
@@ skipping 64 matching lines @@
 
 RenderWidgetHost* RenderWidgetHostViewAura::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewAura::WasShown() {
   DCHECK(host_);
   if (!host_->is_hidden())
     return;
   host_->WasShown();
-  if (framebuffer_holder_)
-    FrameMemoryManager::GetInstance()->SetFrameVisibility(this, true);
+  software_frame_manager_->SetVisibility(true);
 
   aura::RootWindow* root = window_->GetRootWindow();
   if (root) {
     aura::client::CursorClient* cursor_client =
         aura::client::GetCursorClient(root);
     if (cursor_client)
       NotifyRendererOfCursorVisibilityState(cursor_client->IsCursorVisible());
   }
 
   if (!current_surface_.get() && host_->is_accelerated_compositing_active() &&
       !released_front_lock_.get()) {
     ui::Compositor* compositor = GetCompositor();
     if (compositor)
       released_front_lock_ = compositor->GetCompositorLock();
   }
 
 #if defined(OS_WIN)
   LPARAM lparam = reinterpret_cast<LPARAM>(this);
   EnumChildWindows(ui::GetHiddenWindow(), ShowWindowsCallback, lparam);
   transient_observer_->SendPluginCutoutRects();
 #endif
 }
 
 void RenderWidgetHostViewAura::WasHidden() {
   if (!host_ || host_->is_hidden())
     return;
   host_->WasHidden();
-  if (framebuffer_holder_)
-    FrameMemoryManager::GetInstance()->SetFrameVisibility(this, false);
-
+  software_frame_manager_->SetVisibility(false);
   released_front_lock_ = NULL;
 
 #if defined(OS_WIN)
   aura::RootWindow* root_window = window_->GetRootWindow();
   if (root_window) {
     HWND parent = root_window->GetAcceleratedWidget();
     LPARAM lparam = reinterpret_cast<LPARAM>(this);
 
     EnumChildWindows(parent, HideWindowsCallback, lparam);
   }
@@ skipping 538 matching lines @@
   // software mode or set the external texture if going to accelerated mode).
   if (accelerated_compositing_state_changed_)
     accelerated_compositing_state_changed_ = false;
 
   bool is_compositing_active = host_->is_accelerated_compositing_active();
   if (is_compositing_active && current_surface_.get()) {
     window_->layer()->SetExternalTexture(current_surface_.get());
     current_frame_size_ = ConvertSizeToDIP(
         current_surface_->device_scale_factor(), current_surface_->size());
     CheckResizeLock();
-    framebuffer_holder_ = NULL;
-    FrameMemoryManager::GetInstance()->RemoveFrame(this);
-  } else if (is_compositing_active && framebuffer_holder_) {
+    software_frame_manager_->DiscardCurrentFrame();
+  } else if (is_compositing_active &&
+             software_frame_manager_->HasCurrentFrame()) {
     cc::TextureMailbox mailbox;
     scoped_ptr<cc::SingleReleaseCallback> callback;
-    framebuffer_holder_->GetMailbox(&mailbox, &callback);
+    software_frame_manager_->GetCurrentFrameMailbox(&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()->SetShowPaintedContent();
     resize_lock_.reset();
     host_->WasResized();
-    framebuffer_holder_ = NULL;
-    FrameMemoryManager::GetInstance()->RemoveFrame(this);
+    software_frame_manager_->DiscardCurrentFrame();
   }
 }
 
 bool RenderWidgetHostViewAura::SwapBuffersPrepare(
     const gfx::Rect& surface_rect,
     float surface_scale_factor,
     const gfx::Rect& damage_rect,
     const std::string& mailbox_name,
     const BufferPresentedCallback& ack_callback) {
   if (last_swapped_surface_size_ != surface_rect.size()) {
@@ skipping 114 matching lines @@
 
   gfx::Size frame_size = root_pass->output_rect.size();
   gfx::Size frame_size_in_dip =
       ConvertSizeToDIP(frame_device_scale_factor, frame_size);
 
   gfx::Rect damage_rect = gfx::ToEnclosingRect(root_pass->damage_rect);
   damage_rect.Intersect(gfx::Rect(frame_size));
   gfx::Rect damage_rect_in_dip =
       ConvertRectToDIP(frame_device_scale_factor, damage_rect);
 
-  framebuffer_holder_ = NULL;
-  FrameMemoryManager::GetInstance()->RemoveFrame(this);
+  software_frame_manager_->DiscardCurrentFrame();
 
   if (ShouldSkipFrame(frame_size_in_dip)) {
     cc::CompositorFrameAck ack;
     cc::TransferableResource::ReturnResources(frame_data->resource_list,
                                               &ack.resources);
     RenderWidgetHostImpl::SendSwapCompositorFrameAck(
         host_->GetRoutingID(), output_surface_id,
         host_->GetProcess()->GetID(), ack);
     skipped_frames_ = true;
     return;
@@ skipping 113 matching lines @@
   const gfx::Size& frame_size = frame_data->size;
   const gfx::Rect& damage_rect = frame_data->damage_rect;
   gfx::Size frame_size_in_dip =
       ConvertSizeToDIP(frame_device_scale_factor, frame_size);
   if (ShouldSkipFrame(frame_size_in_dip)) {
     ReleaseSoftwareFrame(output_surface_id, frame_data->id);
     SendSoftwareFrameAck(output_surface_id);
     return;
   }
 
-  const size_t size_in_bytes = 4 * frame_size.GetArea();
-#ifdef OS_WIN
-  scoped_ptr<base::SharedMemory> shared_memory(
-      new base::SharedMemory(frame_data->handle, true,
-                             host_->GetProcess()->GetHandle()));
-#else
-  scoped_ptr<base::SharedMemory> shared_memory(
-      new base::SharedMemory(frame_data->handle, true));
-#endif
-
-#ifdef OS_WIN
-  if (!shared_memory->Map(0)) {
-    DLOG(ERROR) << "Unable to map renderer memory.";
-    RecordAction(UserMetricsAction("BadMessageTerminate_RWHVA1"));
+  if (!software_frame_manager_->SwapToNewFrame(
+          output_surface_id,
+          frame_data.get(),
+          frame_device_scale_factor,
+          host_->GetProcess()->GetHandle())) {
     host_->GetProcess()->ReceivedBadMessage();
     return;
   }
 
-  if (shared_memory->mapped_size() < size_in_bytes) {
-    DLOG(ERROR) << "Shared memory too small for given rectangle";
-    RecordAction(UserMetricsAction("BadMessageTerminate_RWHVA2"));
-    host_->GetProcess()->ReceivedBadMessage();
-    return;
-  }
-#else
-  if (!shared_memory->Map(size_in_bytes)) {
-    DLOG(ERROR) << "Unable to map renderer memory.";
-    RecordAction(UserMetricsAction("BadMessageTerminate_RWHVA1"));
-    host_->GetProcess()->ReceivedBadMessage();
-    return;
-  }
-#endif
-
   if (last_swapped_surface_size_ != frame_size) {
     DLOG_IF(ERROR, damage_rect != gfx::Rect(frame_size))
         << "Expected full damage rect";
   }
   last_swapped_surface_size_ = frame_size;
   last_swapped_surface_scale_factor_ = frame_device_scale_factor;
 
-  scoped_refptr<MemoryHolder> holder(new MemoryHolder(
-      shared_memory.Pass(),
-      frame_size,
-      base::Bind(&RenderWidgetHostViewAura::ReleaseSoftwareFrame,
-                 AsWeakPtr(),
-                 output_surface_id,
-                 frame_data->id)));
-  framebuffer_holder_.swap(holder);
   cc::TextureMailbox mailbox;
   scoped_ptr<cc::SingleReleaseCallback> callback;
-  framebuffer_holder_->GetMailbox(&mailbox, &callback);
+  software_frame_manager_->GetCurrentFrameMailbox(&mailbox, &callback);
   DCHECK(mailbox.IsSharedMemory());
   current_frame_size_ = frame_size_in_dip;
 
   released_front_lock_ = NULL;
   CheckResizeLock();
   window_->layer()->SetTextureMailbox(mailbox,
                                       callback.Pass(),
                                       frame_device_scale_factor);
   window_->SchedulePaintInRect(
       ConvertRectToDIP(frame_device_scale_factor, damage_rect));
 
   ui::Compositor* compositor = GetCompositor();
   if (compositor) {
     compositor->SetLatencyInfo(latency_info);
     AddOnCommitCallbackAndDisableLocks(
         base::Bind(&RenderWidgetHostViewAura::SendSoftwareFrameAck,
                    AsWeakPtr(),
                    output_surface_id));
   }
   if (paint_observer_)
     paint_observer_->OnUpdateCompositorContent();
   DidReceiveFrameFromRenderer();
-  FrameMemoryManager::GetInstance()->AddFrame(this, !host_->is_hidden());
+
+  software_frame_manager_->SwapToNewFrameComplete(!host_->is_hidden());
 }
 
 void RenderWidgetHostViewAura::SendSoftwareFrameAck(uint32 output_surface_id) {
   unsigned software_frame_id = 0;
   if (released_software_frame_ &&
       released_software_frame_->output_surface_id == output_surface_id) {
     software_frame_id = released_software_frame_->frame_id;
     released_software_frame_.reset();
   }
 
@@ skipping 87 matching lines @@
 
 void RenderWidgetHostViewAura::BuffersSwapped(
     const gfx::Size& surface_size,
     const gfx::Rect& damage_rect,
     float surface_scale_factor,
     const std::string& mailbox_name,
     const ui::LatencyInfo& latency_info,
     const BufferPresentedCallback& ack_callback) {
   scoped_refptr<ui::Texture> previous_texture(current_surface_);
   const gfx::Rect surface_rect = gfx::Rect(surface_size);
-  framebuffer_holder_ = NULL;
-  FrameMemoryManager::GetInstance()->RemoveFrame(this);
+  software_frame_manager_->DiscardCurrentFrame();
 
   if (!SwapBuffersPrepare(surface_rect,
                           surface_scale_factor,
                           damage_rect,
                           mailbox_name,
                           ack_callback)) {
     return;
   }
 
   SkRegion damage(RectToSkIRect(damage_rect));
@@ skipping 1292 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, aura::RootWindowObserver implementation:
 
 void RenderWidgetHostViewAura::OnRootWindowHostMoved(
     const aura::RootWindow* root,
     const gfx::Point& new_origin) {
   UpdateScreenInfo(window_);
 }
 
-void RenderWidgetHostViewAura::ReleaseCurrentFrame() {
-  if (framebuffer_holder_.get() && !current_surface_.get()) {
-    framebuffer_holder_ = NULL;
-    ui::Compositor* compositor = GetCompositor();
-    if (compositor) {
-      AddOnCommitCallbackAndDisableLocks(base::Bind(
-          &RenderWidgetHostViewAura::SendReclaimSoftwareFrames, AsWeakPtr()));
-    }
-    UpdateExternalTexture();
+////////////////////////////////////////////////////////////////////////////////
+// RenderWidgetHostViewAura, SoftwareFrameManagerClient implementation:
+
+void RenderWidgetHostViewAura::SoftwareFrameWasFreed(
+    uint32 output_surface_id, unsigned frame_id) {
+  ReleaseSoftwareFrame(output_surface_id, frame_id);
+}
+
+void RenderWidgetHostViewAura::ReleaseReferencesToSoftwareFrame() {
+  ui::Compositor* compositor = GetCompositor();
+  if (compositor) {
+    AddOnCommitCallbackAndDisableLocks(base::Bind(
+        &RenderWidgetHostViewAura::SendReclaimSoftwareFrames, AsWeakPtr()));
   }
+  UpdateExternalTexture();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ui::CompositorObserver implementation:
 
 void RenderWidgetHostViewAura::OnCompositingDidCommit(
     ui::Compositor* compositor) {
   if (can_lock_compositor_ == NO_PENDING_COMMIT) {
     can_lock_compositor_ = YES;
     if (resize_lock_.get() && resize_lock_->GrabDeferredLock())
@@ skipping 153 matching lines @@
            popup_child_host_view_->popup_parent_host_view_ == this);
     popup_child_host_view_->popup_parent_host_view_ = NULL;
   }
   aura::client::SetTooltipText(window_, NULL);
   gfx::Screen::GetScreenFor(window_)->RemoveObserver(this);
 
   // This call is usually no-op since |this| object is already removed from the
   // Aura root window and we don't have a way to get an input method object
   // associated with the window, but just in case.
   DetachFromInputMethod();
-  FrameMemoryManager::GetInstance()->RemoveFrame(this);
-  // The destruction of the holder may call back into the RWHVA, so do it
-  // early.
-  framebuffer_holder_ = NULL;
 
   if (resource_collection_.get())
     resource_collection_->SetClient(NULL);
 }
 
 void RenderWidgetHostViewAura::UpdateCursorIfOverSelf() {
   const gfx::Point screen_point =
       gfx::Screen::GetScreenFor(GetNativeView())->GetCursorScreenPoint();
   aura::RootWindow* root_window = window_->GetRootWindow();
   if (!root_window)
@@ skipping 195 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content