cc: Don't attempt main thread synchronization if it is slow.

cc/trees/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/thread_proxy.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 1054 matching lines @@
   bool smoothness_takes_priority =
       impl().layer_tree_host_impl->pinch_gesture_active() ||
       impl().layer_tree_host_impl->page_scale_animation_active() ||
       impl().layer_tree_host_impl->IsActivelyScrolling();
 
   // Schedule expiration if smoothness currently takes priority.
   if (smoothness_takes_priority)
     impl().smoothness_priority_expiration_notifier.Schedule();
 
   // We use the same priority for both trees by default.
-  TreePriority priority = SAME_PRIORITY_FOR_BOTH_TREES;
+  TreePriority tree_priority = SAME_PRIORITY_FOR_BOTH_TREES;
 
   // Smoothness takes priority if we have an expiration for it scheduled.
   if (impl().smoothness_priority_expiration_notifier.HasPendingNotification())
-    priority = SMOOTHNESS_TAKES_PRIORITY;
+    tree_priority = SMOOTHNESS_TAKES_PRIORITY;
 
   // New content always takes priority when there is an invalid viewport size or
   // ui resources have been evicted.
   if (impl().layer_tree_host_impl->active_tree()->ViewportSizeInvalid() ||
       impl().layer_tree_host_impl->EvictedUIResourcesExist() ||
       impl().input_throttled_until_commit) {
     // Once we enter NEW_CONTENTS_TAKES_PRIORITY mode, visible tiles on active
     // tree might be freed. We need to set RequiresHighResToDraw to ensure that
     // high res tiles will be required to activate pending tree.
     impl().layer_tree_host_impl->SetRequiresHighResToDraw();
-    priority = NEW_CONTENT_TAKES_PRIORITY;
+    tree_priority = NEW_CONTENT_TAKES_PRIORITY;
   }
 
-  impl().layer_tree_host_impl->SetTreePriority(priority);
+  impl().layer_tree_host_impl->SetTreePriority(tree_priority);
 
   // Only put the scheduler in impl latency prioritization mode if we don't
   // have a scroll listener. This gives the scroll listener a better chance of
   // handling scroll updates within the same frame. The tree itself is still
   // kept in prefer smoothness mode to allow checkerboarding.
-  impl().scheduler->SetImplLatencyTakesPriority(
-      priority == SMOOTHNESS_TAKES_PRIORITY &&
-      !impl().layer_tree_host_impl->scroll_affects_scroll_handler());
+  ScrollHandlerState scroll_handler_state =
+      impl().layer_tree_host_impl->scroll_affects_scroll_handler()
+          ? SCROLL_AFFECTS_SCROLL_HANDLER
+          : SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER;
+  impl().scheduler->SetSmoothnessMode(tree_priority, scroll_handler_state);
 
   // Notify the the client of this compositor via the output surface.
   // TODO(epenner): Route this to compositor-thread instead of output-surface
   // after GTFO refactor of compositor-thread (http://crbug/170828).
   if (impl().layer_tree_host_impl->output_surface()) {
     impl()
         .layer_tree_host_impl->output_surface()
-        ->UpdateSmoothnessTakesPriority(priority == SMOOTHNESS_TAKES_PRIORITY);
+        ->UpdateSmoothnessTakesPriority(tree_priority ==
+                                        SMOOTHNESS_TAKES_PRIORITY);
   }
 }
 
 void ThreadProxy::PostDelayedAnimationTaskOnImplThread(
     const base::Closure& task,
     base::TimeDelta delay) {
   task_runner_provider_->ImplThreadTaskRunner()->PostDelayedTask(FROM_HERE,
                                                                  task, delay);
 }
 
@@ skipping 67 matching lines @@
 
 base::WeakPtr<ProxyMain> ThreadProxy::GetMainWeakPtr() {
   return main_thread_weak_ptr_;
 }
 
 base::WeakPtr<ProxyImpl> ThreadProxy::GetImplWeakPtr() {
   return impl_thread_weak_ptr_;
 }
 
 }  // namespace cc