Aura: Resize locks with --ui-enable-threaded-compositing

ui/compositor/compositor.cc

Index: ui/compositor/compositor.cc
diff --git a/ui/compositor/compositor.cc b/ui/compositor/compositor.cc
index 65a7a75e5acde6202027f27db6c8be408ba949fc..7a1739ef791caca725cc925c091988499d788912 100644
--- a/ui/compositor/compositor.cc
+++ b/ui/compositor/compositor.cc
@@ -6,7 +6,9 @@
 
 #include <algorithm>
 
+#include "base/bind.h"
 #include "base/command_line.h"
+#include "base/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/images/SkImageEncoder.h"
@@ -40,6 +42,8 @@ bool test_compositor_enabled = false;
 
 ui::ContextFactory* g_context_factory = NULL;
 
+const int kCompositorLockTimeoutMs = 67;
+
 }  // namespace
 
 namespace ui {
@@ -129,6 +133,25 @@ Texture::Texture(bool flipped, const gfx::Size& size)
 Texture::~Texture() {
 }
 
+CompositorLock::CompositorLock(Compositor* compositor)
+    : compositor_(compositor) {
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CompositorLock::CancelLock, AsWeakPtr()),
+      base::TimeDelta::FromMilliseconds(kCompositorLockTimeoutMs));
+}
+
+CompositorLock::~CompositorLock() {
+  CancelLock();
+}
+
+void CompositorLock::CancelLock() {
+  if (!compositor_)
+    return;
+  compositor_->Unlock();
+  compositor_ = NULL;
+}
+
 Compositor::Compositor(CompositorDelegate* delegate,
                        gfx::AcceleratedWidget widget)
     : delegate_(delegate),
@@ -139,7 +162,10 @@ Compositor::Compositor(CompositorDelegate* delegate,
       device_scale_factor_(0.0f),
       last_started_frame_(0),
       last_ended_frame_(0),
-      disable_schedule_composite_(false) {
+      last_commit_id_(0),
+      disable_schedule_composite_(false),
+      updates_allowed_(ENABLED_NEEDS_UPDATE),
+      compositor_lock_(NULL) {
   WebKit::WebLayerTreeView::Settings settings;
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   settings.showFPSCounter =
@@ -162,6 +188,11 @@ Compositor::Compositor(CompositorDelegate* delegate,
 }
 
 Compositor::~Compositor() {
+  if (compositor_lock_) {
+    compositor_lock_->CancelLock();
+    DCHECK(!compositor_lock_);
+  }
+
   // Don't call |CompositorDelegate::ScheduleDraw| from this point.
   delegate_ = NULL;
   // There's a cycle between |root_web_layer_| and |host_|, which results in
@@ -230,10 +261,12 @@ void Compositor::Draw(bool force_clear) {
     return;
 
   last_started_frame_++;
-  if (!g_compositor_thread)
-    FOR_EACH_OBSERVER(CompositorObserver,
-                      observer_list_,
-                      OnCompositingWillStart(this));
+
+  // Fast track draw because visible state could not have changed.
+  if (!g_compositor_thread && updates_allowed_ == DISABLED) {
+    NotifyEnd();

[piman, 2012/07/31 23:42:17]

Should we also send the OnCompositingStarted callbacks? Some observers might
expect the Started/Ended to come in pairs.

[jonathan.backer, 2012/08/01 17:22:43]

Done.

+    return;
+  }
 
   // TODO(nduca): Temporary while compositor calls
   // compositeImmediately() directly.
@@ -297,10 +330,6 @@ bool Compositor::HasObserver(CompositorObserver* observer) {
   return observer_list_.HasObserver(observer);
 }
 
-bool Compositor::IsThreaded() const {
-  return g_compositor_thread != NULL;
-}
-
 void Compositor::OnSwapBuffersPosted() {
   swap_posted_ = true;
 }
@@ -354,18 +383,19 @@ void Compositor::didRebindGraphicsContext(bool success) {
 // Called once per draw in single-threaded compositor mode and potentially
 // many times between draws in the multi-threaded compositor mode.
 void Compositor::didCommit() {
-  FOR_EACH_OBSERVER(CompositorObserver,
-                    observer_list_,
-                    OnCompositingDidCommit(this));
+  if (updates_allowed_ != DISABLED)
+    last_commit_id_++;
+
+  if (updates_allowed_ == DISABLED_PENDING_UPDATE) {
+    updates_allowed_ = DISABLED;
+    root_web_layer_.setDeferUpdates(true);
+  }
+
+  if (updates_allowed_ == ENABLED_NEEDS_UPDATE)
+    updates_allowed_ = ENABLED_DID_UPDATE;
 }
 
 void Compositor::didCommitAndDrawFrame() {
-  // TODO(backer): Plumb through an earlier impl side will start.
-  if (g_compositor_thread)
-    FOR_EACH_OBSERVER(CompositorObserver,
-                      observer_list_,
-                      OnCompositingWillStart(this));
-
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingStarted(this));
@@ -380,6 +410,27 @@ void Compositor::scheduleComposite() {
     ScheduleDraw();
 }
 
+scoped_refptr<CompositorLock> Compositor::GetCompositorLock() {
+  if (!compositor_lock_) {
+    compositor_lock_ = new CompositorLock(this);
+    if (updates_allowed_ == ENABLED_NEEDS_UPDATE) {
+      updates_allowed_ = DISABLED_PENDING_UPDATE;
+    } else {
+      updates_allowed_ = DISABLED;
+      root_web_layer_.setDeferUpdates(true);
+    }
+  }
+  return compositor_lock_;
+}
+
+void Compositor::Unlock() {
+  DCHECK(compositor_lock_);
+  compositor_lock_ = NULL;
+
+  updates_allowed_ = ENABLED_NEEDS_UPDATE;
+  root_web_layer_.setDeferUpdates(false);
+}
+
 void Compositor::SwizzleRGBAToBGRAAndFlip(unsigned char* pixels,
                                           const gfx::Size& image_size) {
   // Swizzle from RGBA to BGRA