cc: Commit directly to active tree when using single thread.

cc/trees/single_thread_proxy.cc

 // Copyright 2011 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 "cc/trees/single_thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/output/context_provider.h"
@@ skipping 64 matching lines @@
     DebugScopedSetImplThread impl(this);
     layer_tree_host_impl_->FinishAllRendering();
   }
 }
 
 bool SingleThreadProxy::IsStarted() const {
   DCHECK(Proxy::IsMainThread());
   return layer_tree_host_impl_;
 }
 
+bool SingleThreadProxy::CommitToActiveTree() const {
+  // With SingleThreadProxy we skip the pending tree and commit directly to the
+  // active tree.
+  return false;

[enne (OOO), 2015/01/28 01:14:53]

...false?!

[danakj, 2015/01/28 01:28:20]

Oh thats why my unittests started passing. thanks :D

+}
+
 void SingleThreadProxy::SetLayerTreeHostClientReady() {
   TRACE_EVENT0("cc", "SingleThreadProxy::SetLayerTreeHostClientReady");
   // Scheduling is controlled by the embedder in the single thread case, so
   // nothing to do.
   DCHECK(Proxy::IsMainThread());
   DebugScopedSetImplThread impl(this);
   if (layer_tree_host_->settings().single_thread_proxy_scheduler &&
       !scheduler_on_impl_thread_) {
     SchedulerSettings scheduler_settings(layer_tree_host_->settings());
     scheduler_settings.main_thread_should_always_be_low_latency = true;
@@ skipping 148 matching lines @@
     // In the single-threaded case, the scale and scroll deltas should never be
     // touched on the impl layer tree.
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         layer_tree_host_impl_->ProcessScrollDeltas();
     DCHECK(!scroll_info->scrolls.size());
     DCHECK_EQ(1.f, scroll_info->page_scale_delta);
 #endif
   }
 
   if (layer_tree_host_->settings().impl_side_painting) {
-    // TODO(enne): just commit directly to the active tree.
-    //
-    // Synchronously activate during commit to satisfy any potential
+    // Commit goes directly to the active tree, but we need to synchronously
+    // "activate" the tree still during commit to satisfy any potential
     // SetNextCommitWaitsForActivation calls.  Unfortunately, the tree
     // might not be ready to draw, so DidActivateSyncTree must set
     // the flag to force the tree to not draw until textures are ready.
     NotifyReadyToActivate();
   } else {
     CommitComplete();
   }
 }
 
 void SingleThreadProxy::CommitComplete() {
@@ skipping 160 matching lines @@
   return contents_texture_manager->ReduceMemoryOnImplThread(
       limit_bytes, priority_cutoff, resource_provider);
 }
 
 bool SingleThreadProxy::IsInsideDraw() { return inside_draw_; }
 
 void SingleThreadProxy::DidActivateSyncTree() {
   // Non-impl-side painting finishes commit in DoCommit.  Impl-side painting
   // defers until here to simulate SetNextCommitWaitsForActivation.
   if (layer_tree_host_impl_->settings().impl_side_painting) {
-    // This is required because NotifyReadyToActivate gets called when
-    // the pending tree is not actually ready in the SingleThreadProxy.
+    // This is required because NotifyReadyToActivate gets called immediately
+    // after commit since single thread commits directly to the active tree.
     layer_tree_host_impl_->SetRequiresHighResToDraw();
 
     CommitComplete();
   }
 
   timing_history_.DidActivateSyncTree();
 }
 
 void SingleThreadProxy::DidPrepareTiles() {
   DCHECK(layer_tree_host_impl_->settings().impl_side_painting);
@@ skipping 366 matching lines @@
 
 void SingleThreadProxy::DidBeginImplFrameDeadline() {
   layer_tree_host_impl_->ResetCurrentBeginFrameArgsForNextFrame();
 }
 
 void SingleThreadProxy::SendBeginFramesToChildren(const BeginFrameArgs& args) {
   layer_tree_host_->SendBeginFramesToChildren(args);
 }
 
 }  // namespace cc