cc: Release main thread earlier

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 <string>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 74 matching lines @@
       commit_requested_(false),
       commit_request_sent_to_impl_thread_(false),
       created_offscreen_context_provider_(false),
       layer_tree_host_unsafe_(layer_tree_host),
       contents_texture_manager_unsafe_(NULL),
       started_(false),
       textures_acquired_(true),
       in_composite_and_readback_(false),
       manage_tiles_pending_(false),
       commit_waits_for_activation_(false),
-      inside_commit_(false),
+      main_thread_inside_commit_(false),
       begin_main_frame_sent_completion_event_on_impl_thread_(NULL),
       readback_request_on_impl_thread_(NULL),
       commit_completion_event_on_impl_thread_(NULL),
       completion_event_for_commit_held_on_tree_activation_(NULL),
       texture_acquisition_completion_event_on_impl_thread_(NULL),
       next_frame_is_newly_committed_frame_on_impl_thread_(false),
       throttle_frame_production_(
           layer_tree_host->settings().throttle_frame_production),
       begin_impl_frame_scheduling_enabled_(
           layer_tree_host->settings().begin_impl_frame_scheduling_enabled),
@@ skipping 407 matching lines @@
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsRedraw");
   Proxy::ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::SetNeedsRedrawRectOnImplThread,
                  impl_thread_weak_ptr_,
                  damage_rect));
 }
 
 void ThreadProxy::SetNextCommitWaitsForActivation() {
   DCHECK(IsMainThread());
-  DCHECK(!inside_commit_);
+  DCHECK(!main_thread_inside_commit_);
   commit_waits_for_activation_ = true;
 }
 
 void ThreadProxy::SetDeferCommits(bool defer_commits) {
   DCHECK(IsMainThread());
   DCHECK_NE(defer_commits_, defer_commits);
   defer_commits_ = defer_commits;
 
   if (defer_commits_)
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ThreadProxy::SetDeferCommits", this);
@@ skipping 478 matching lines @@
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionCommit");
   DCHECK(IsImplThread());
   DCHECK(IsMainThreadBlocked());
   DCHECK(commit_completion_event_on_impl_thread_);
   DCHECK(current_resource_update_controller_on_impl_thread_);
 
   // Complete all remaining texture updates.
   current_resource_update_controller_on_impl_thread_->Finalize();
   current_resource_update_controller_on_impl_thread_.reset();
 
-  inside_commit_ = true;
+  main_thread_inside_commit_ = true;
   layer_tree_host_impl_->BeginCommit();
   layer_tree_host()->BeginCommitOnImplThread(layer_tree_host_impl_.get());
   layer_tree_host()->FinishCommitOnImplThread(layer_tree_host_impl_.get());
-  layer_tree_host_impl_->CommitComplete();
-  inside_commit_ = false;
-
-  SetInputThrottledUntilCommitOnImplThread(false);
-
-  UpdateBackgroundAnimateTicking();
-
-  next_frame_is_newly_committed_frame_on_impl_thread_ = true;
+  main_thread_inside_commit_ = false;
 
   bool hold_commit = layer_tree_host()->settings().impl_side_painting &&
                      commit_waits_for_activation_;
   commit_waits_for_activation_ = false;
 
   if (hold_commit) {
     // For some layer types in impl-side painting, the commit is held until
     // the pending tree is activated.  It's also possible that the
     // pending tree has already activated if there was no work to be done.
     TRACE_EVENT_INSTANT0("cc", "HoldCommit", TRACE_EVENT_SCOPE_THREAD);
     completion_event_for_commit_held_on_tree_activation_ =
         commit_completion_event_on_impl_thread_;
     commit_completion_event_on_impl_thread_ = NULL;
   } else {
     commit_completion_event_on_impl_thread_->Signal();
     commit_completion_event_on_impl_thread_ = NULL;
   }
 
+  // Delay this step until afer the main thread has been released as it's
+  // often a good bit of work to update the tree and prepare the new frame.
+  layer_tree_host_impl_->CommitComplete();
+
+  SetInputThrottledUntilCommitOnImplThread(false);
+
+  UpdateBackgroundAnimateTicking();
+
+  next_frame_is_newly_committed_frame_on_impl_thread_ = true;
+  commit_waits_for_activation_ = false;
+
   commit_complete_time_ = base::TimeTicks::HighResNow();
   begin_main_frame_to_commit_duration_history_.InsertSample(
       commit_complete_time_ - begin_main_frame_sent_time_);
 
   // SetVisible kicks off the next scheduler action, so this must be last.
   scheduler_on_impl_thread_->SetVisible(layer_tree_host_impl_->visible());
 }
 
 void ThreadProxy::ScheduledActionUpdateVisibleTiles() {
   DCHECK(IsImplThread());
@@ skipping 587 matching lines @@
   commit_to_activate_duration_history_.InsertSample(
       base::TimeTicks::HighResNow() - commit_complete_time_);
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   scheduler_on_impl_thread_->DidManageTiles();
 }
 
 }  // namespace cc