Mac: Clean up ui::Compositor recycling

content/browser/renderer_host/browser_compositor_view_mac.mm

 // Copyright 2014 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/browser_compositor_view_mac.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/compositor/image_transport_factory.h"
 #include "content/browser/renderer_host/resize_lock.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/context_factory.h"
 #include "ui/accelerated_widget_mac/accelerated_widget_mac.h"
 #include "ui/accelerated_widget_mac/window_resize_helper_mac.h"
 #include "ui/base/layout.h"
 #include "ui/gfx/geometry/dip_util.h"
 
 namespace content {
 
 namespace {
 
 // Set when no browser compositors should remain alive.
 bool g_has_shut_down = false;
 
 // The number of placeholder objects allocated. If this reaches zero, then
 // the RecyclableCompositorMac being held on to for recycling,
-// |g_spare_recyclable_compositor|, will be freed.
+// |g_spare_recyclable_compositors|, will be freed.
 uint32_t g_browser_compositor_count = 0;
 
 // A spare RecyclableCompositorMac kept around for recycling.
-base::LazyInstance<std::unique_ptr<RecyclableCompositorMac>>
-    g_spare_recyclable_compositor;
+base::LazyInstance<std::deque<std::unique_ptr<RecyclableCompositorMac>>>
+    g_spare_recyclable_compositors;
+
+void ReleaseSpareCompositors() {
+  // Allow at most one spare recyclable compositor.
+  while (g_spare_recyclable_compositors.Get().size() > 1)
+    g_spare_recyclable_compositors.Get().pop_front();
+
+  if (!g_browser_compositor_count)
+    g_spare_recyclable_compositors.Get().clear();
+}
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // RecyclableCompositorMac
 
 // A ui::Compositor and a gfx::AcceleratedWidget (and helper) that it draws
 // into. This structure is used to efficiently recycle these structures across
 // tabs (because creating a new ui::Compositor for each tab would be expensive
 // in terms of time and resources).
@@ skipping 67 matching lines @@
 void RecyclableCompositorMac::OnCompositingDidCommit(
     ui::Compositor* compositor_that_did_commit) {
   DCHECK_EQ(compositor_that_did_commit, compositor());
   content::ImageTransportFactory::GetInstance()
       ->SetCompositorSuspendedForRecycle(compositor(), false);
 }
 
 // static
 std::unique_ptr<RecyclableCompositorMac> RecyclableCompositorMac::Create() {
   DCHECK(ui::WindowResizeHelperMac::Get()->task_runner());
-  if (g_spare_recyclable_compositor.Get())
-    return std::move(g_spare_recyclable_compositor.Get());
+  if (!g_spare_recyclable_compositors.Get().empty()) {
+    std::unique_ptr<RecyclableCompositorMac> result;
+    result = std::move(g_spare_recyclable_compositors.Get().front());
+    g_spare_recyclable_compositors.Get().pop_front();

[enne (OOO), 2016/07/20 23:53:48]

Did you want to delete the remaining spare compositors here, if they exist? Or
the case where there is more than one is only when there is an outstanding
cleanup task?

[ccameron, 2016/07/20 23:59:33]

There will only be >0 when there is an outstanding cleanup task -- we want to
avoid doing the cleanup here, cause if we're here, we probably just created a
window/tab that is going to want to paint (and is going to be doing that in a
nested loop -- we'd rather not hit the dtor inside that nested loop).

+    return result;
+  }
   return std::unique_ptr<RecyclableCompositorMac>(new RecyclableCompositorMac);
 }
 
 // static
 void RecyclableCompositorMac::Recycle(
     std::unique_ptr<RecyclableCompositorMac> compositor) {
   DCHECK(compositor);
   content::ImageTransportFactory::GetInstance()
       ->SetCompositorSuspendedForRecycle(compositor->compositor(), true);
 
   // It is an error to have a browser compositor continue to exist after
   // shutdown.
   CHECK(!g_has_shut_down);
 
   // Make this RecyclableCompositorMac recyclable for future instances.
-  g_spare_recyclable_compositor.Get().swap(compositor);
+  g_spare_recyclable_compositors.Get().push_back(std::move(compositor));
 
-  // If there are no placeholders allocated, destroy the recyclable
-  // RecyclableCompositorMac that we just populated.
-  if (!g_browser_compositor_count)
-    g_spare_recyclable_compositor.Get().reset();
+  // Post a task to free up the spare ui::Compositors when needed. Post this
+  // to the browser main thread so that we won't free any compositors while
+  // in a nested loop waiting to put up a new frame.
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE, base::Bind(&ReleaseSpareCompositors));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserCompositorMac
 
 BrowserCompositorMac::BrowserCompositorMac(
     ui::AcceleratedWidgetMacNSView* accelerated_widget_mac_ns_view,
     BrowserCompositorMacClient* client,
     bool render_widget_host_is_hidden,
     bool ns_view_attached_to_window)
@@ skipping 17 matching lines @@
   TransitionToState(HasNoCompositor);
   delegated_frame_host_.reset();
   root_layer_.reset();
 
   DCHECK_GT(g_browser_compositor_count, 0u);
   g_browser_compositor_count -= 1;
 
   // If there are no compositors allocated, destroy the recyclable
   // RecyclableCompositorMac.
   if (!g_browser_compositor_count)
-    g_spare_recyclable_compositor.Get().reset();
+    g_spare_recyclable_compositors.Get().clear();
 }
 
 ui::AcceleratedWidgetMac* BrowserCompositorMac::GetAcceleratedWidgetMac() {
   if (recyclable_compositor_)
     return recyclable_compositor_->accelerated_widget_mac();
   return nullptr;
 }
 
 DelegatedFrameHost* BrowserCompositorMac::GetDelegatedFrameHost() {
   DCHECK(delegated_frame_host_);
@@ skipping 166 matching lines @@
     recyclable_compositor_->compositor()->SetScaleAndSize(1.0, gfx::Size(0, 0));
     recyclable_compositor_->compositor()->SetRootLayer(nullptr);
     RecyclableCompositorMac::Recycle(std::move(recyclable_compositor_));
     state_ = HasNoCompositor;
   }
 }
 
 // static
 void BrowserCompositorMac::DisableRecyclingForShutdown() {
   g_has_shut_down = true;
-  g_spare_recyclable_compositor.Get().reset();
+  g_spare_recyclable_compositors.Get().clear();
 }
 
 void BrowserCompositorMac::SetNeedsBeginFrames(bool needs_begin_frames) {
   if (needs_begin_frames_ == needs_begin_frames)
     return;
 
   needs_begin_frames_ = needs_begin_frames;
   if (begin_frame_source_) {
     if (needs_begin_frames_)
       begin_frame_source_->AddObserver(this);
@@ skipping 81 matching lines @@
 
 const cc::BeginFrameArgs& BrowserCompositorMac::LastUsedBeginFrameArgs() const {
   return last_begin_frame_args_;
 }
 
 void BrowserCompositorMac::OnBeginFrameSourcePausedChanged(bool paused) {
   // Only used on Android WebView.
 }
 
 }  // namespace content