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 74 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 451 matching lines @@
       window_(new aura::Window(this)),
       in_shutdown_(false),
       is_fullscreen_(false),
       popup_parent_host_view_(NULL),
       popup_child_host_view_(NULL),
       is_loading_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
       can_compose_inline_(true),
       has_composition_text_(false),
+      software_framebuffer_(new SoftwareFramebuffer(
+          this, RenderWidgetHostImpl::From(host))),
       last_output_surface_id_(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) {
@@ skipping 84 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_framebuffer_->WasShown();
 
   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_framebuffer_->WasHidden();
 
   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 539 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_framebuffer_->DiscardCurrentFrame();
+  } else if (is_compositing_active &&
+             software_framebuffer_->HasCurrentFrame()) {
     cc::TextureMailbox mailbox;
     scoped_ptr<cc::SingleReleaseCallback> callback;
-    framebuffer_holder_->GetMailbox(&mailbox, &callback);
+    software_framebuffer_->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_framebuffer_->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_framebuffer_->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 59 matching lines @@
 void RenderWidgetHostViewAura::SwapSoftwareFrame(
     uint32 output_surface_id,
     scoped_ptr<cc::SoftwareFrameData> frame_data,
     float frame_device_scale_factor,
     const ui::LatencyInfo& latency_info) {
   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);
+    software_framebuffer_->ReleaseSoftwareFrame(output_surface_id,
+                                                frame_data->id);
+    software_framebuffer_->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
+  software_framebuffer_->SwapToNewFrame(

[ccameron, 2013/10/03 21:46:00]

This is a functional change, in that we have fused FrameMemoryManager::AddFrame
and SwapToNewFrame. If this frame is to a backgrounded tab, it may be instantly
evicted.

In that case, this code acts more like the code in ShouldSkipFrame instead of
proceeding through, then deleting the frame at the end of the function.

[piman, 2013/10/08 02:58:38]

Can the eviction cause re-entrancy? Is that ok?
Can I haz tests?

[ccameron, 2013/10/22 07:15:55]

The potentialy re-entrancy seemed too iffy... changed this back to two steps.

+      output_surface_id, frame_data.get(), frame_device_scale_factor);
 
-  if (!shared_memory->Map(size_in_bytes)) {
-    host_->GetProcess()->ReceivedBadMessage();
+  // The frame may have immediately evicted if this view is not visible.
+  if (!software_framebuffer_->HasCurrentFrame()) {
+    software_framebuffer_->SendSoftwareFrameAck(output_surface_id);
     return;
   }
 
   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_framebuffer_->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(),
+        base::Bind(&SoftwareFramebuffer::SendSoftwareFrameAck,
+                   software_framebuffer_->AsWeakPtr(),
                    output_surface_id));
   }
   if (paint_observer_)
     paint_observer_->OnUpdateCompositorContent();
   DidReceiveFrameFromRenderer();
-  FrameMemoryManager::GetInstance()->AddFrame(this, !host_->is_hidden());
-}
-
-void RenderWidgetHostViewAura::SendSoftwareFrameAck(uint32 output_surface_id) {
-  unsigned software_frame_id = 0;
-  if (!released_software_frames_.empty()) {
-    unsigned released_output_surface_id =
-        released_software_frames_.back().output_surface_id;
-    if (released_output_surface_id == output_surface_id) {
-      software_frame_id = released_software_frames_.back().frame_id;
-      released_software_frames_.pop_back();
-    }
-  }
-
-  cc::CompositorFrameAck ack;
-  ack.last_software_frame_id = software_frame_id;
-  RenderWidgetHostImpl::SendSwapCompositorFrameAck(
-      host_->GetRoutingID(), output_surface_id,
-      host_->GetProcess()->GetID(), ack);
-  SendReclaimSoftwareFrames();
-}
-
-void RenderWidgetHostViewAura::SendReclaimSoftwareFrames() {
-  while (!released_software_frames_.empty()) {
-    cc::CompositorFrameAck ack;
-    ack.last_software_frame_id = released_software_frames_.back().frame_id;
-    RenderWidgetHostImpl::SendReclaimCompositorResources(
-        host_->GetRoutingID(),
-        released_software_frames_.back().output_surface_id,
-        host_->GetProcess()->GetID(),
-        ack);
-    released_software_frames_.pop_back();
-  }
-}
-
-void RenderWidgetHostViewAura::ReleaseSoftwareFrame(
-    uint32 output_surface_id,
-    unsigned software_frame_id) {
-  SendReclaimSoftwareFrames();
-  released_software_frames_.push_back(
-      ReleasedFrameInfo(output_surface_id, software_frame_id));
 }
 
 void RenderWidgetHostViewAura::OnSwapCompositorFrame(
     uint32 output_surface_id,
     scoped_ptr<cc::CompositorFrame> frame) {
   TRACE_EVENT0("content", "RenderWidgetHostViewAura::OnSwapCompositorFrame");
   if (frame->delegated_frame_data) {
     SwapDelegatedFrame(output_surface_id,
                        frame->delegated_frame_data.Pass(),
                        frame->metadata.device_scale_factor,
@@ skipping 49 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_framebuffer_->DiscardCurrentFrame();
 
   if (!SwapBuffersPrepare(surface_rect,
                           surface_scale_factor,
                           damage_rect,
                           mailbox_name,
                           ack_callback)) {
     return;
   }
 
   SkRegion damage(RectToSkIRect(damage_rect));
@@ skipping 1283 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, aura::RootWindowObserver implementation:
 
 void RenderWidgetHostViewAura::OnRootWindowHostMoved(
     const aura::RootWindow* root,
     const gfx::Point& new_origin) {
   UpdateScreenInfo(window_);
 }
 
-void RenderWidgetHostViewAura::ReleaseCurrentFrame() {

[ccameron, 2013/10/03 21:46:00]

This is a functional change in that we now ignore current_surface_ and
unconditionally reclaim frames.

-  if (framebuffer_holder_.get() && !current_surface_.get()) {
-    framebuffer_holder_ = NULL;
-    ui::Compositor* compositor = GetCompositor();
-    if (compositor) {
-      AddOnCommitCallbackAndDisableLocks(base::Bind(
-          &RenderWidgetHostViewAura::SendReclaimSoftwareFrames, AsWeakPtr()));
-    }
-    UpdateExternalTexture();
+////////////////////////////////////////////////////////////////////////////////
+// RenderWidgetHostViewAura, SoftwareFramebufferClient implementation:
+
+void RenderWidgetHostViewAura::CurrentSoftwareFrameWasDiscarded() {
+  ui::Compositor* compositor = GetCompositor();
+  if (compositor) {
+    AddOnCommitCallbackAndDisableLocks(base::Bind(
+        &SoftwareFramebuffer::SendReclaimSoftwareFrames,
+        software_framebuffer_->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;

[ccameron, 2013/10/03 21:46:00]

The SoftwareFramebuffer destructor un-sets is back-pointer to the
RenderWidgetHost and view, so any callbacks that come in during tear-down will
not reach the (now-dead) view.

 }
 
 void RenderWidgetHostViewAura::UpdateCursorIfOverSelf() {
   const gfx::Point screen_point =
       gfx::Screen::GetScreenFor(GetNativeView())->GetCursorScreenPoint();
   aura::RootWindow* root_window = window_->GetRootWindow();
   if (!root_window)
     return;
 
   gfx::Rect screen_rect = GetViewBounds();
@@ skipping 189 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content