cc: Remove ResourceUpdateQueue and ResourceUpdateController.

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 747 matching lines @@
 
   // Clear the commit flag after updating animations and layout here --- objects
   // that only layout when painted will trigger another SetNeedsCommit inside
   // UpdateLayers.
   main().commit_requested = false;
   main().commit_request_sent_to_impl_thread = false;
   bool can_cancel_this_commit =
       main().can_cancel_commit && !begin_main_frame_state->evicted_ui_resources;
   main().can_cancel_commit = true;
 
-  scoped_ptr<ResourceUpdateQueue> queue =
-      make_scoped_ptr(new ResourceUpdateQueue);
-
   bool updated = layer_tree_host()->UpdateLayers();
 
   layer_tree_host()->WillCommit();
   devtools_instrumentation::ScopedCommitTrace commit_task(
       layer_tree_host()->id());
 
   // Before calling animate, we set main().animate_requested to false. If it is
   // true now, it means SetNeedAnimate was called again, but during a state when
   // main().commit_request_sent_to_impl_thread = true. We need to force that
   // call to happen again now so that the commit request is sent to the impl
@@ skipping 30 matching lines @@
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
     // This CapturePostTasks should be destroyed before CommitComplete() is
     // called since that goes out to the embedder, and we want the embedder
     // to receive its callbacks before that.
     BlockingTaskRunner::CapturePostTasks blocked(
         blocking_main_thread_task_runner());
 
     CompletionEvent completion;
     Proxy::ImplThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&ThreadProxy::StartCommitOnImplThread,
-                   impl_thread_weak_ptr_,
-                   &completion,
-                   queue.release()));
+        FROM_HERE, base::Bind(&ThreadProxy::StartCommitOnImplThread,
+                              impl_thread_weak_ptr_, &completion));
     completion.Wait();
   }
 
   layer_tree_host()->CommitComplete();
   layer_tree_host()->DidBeginMainFrame();
 }
 
 void ThreadProxy::BeginMainFrameNotExpectedSoon() {
   TRACE_EVENT0("cc", "ThreadProxy::BeginMainFrameNotExpectedSoon");
   DCHECK(IsMainThread());
   layer_tree_host()->BeginMainFrameNotExpectedSoon();
 }
 
-void ThreadProxy::StartCommitOnImplThread(CompletionEvent* completion,
-                                          ResourceUpdateQueue* raw_queue) {
+void ThreadProxy::StartCommitOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::StartCommitOnImplThread");
   DCHECK(!impl().commit_completion_event);
   DCHECK(IsImplThread() && IsMainThreadBlocked());
   DCHECK(impl().scheduler);
   DCHECK(impl().scheduler->CommitPending());
 
   if (!impl().layer_tree_host_impl) {
     TRACE_EVENT_INSTANT0(
         "cc", "EarlyOut_NoLayerTree", TRACE_EVENT_SCOPE_THREAD);
     completion->Signal();
     return;
   }
 
   // Ideally, we should inform to impl thread when BeginMainFrame is started.
   // But, we can avoid a PostTask in here.
   impl().scheduler->NotifyBeginMainFrameStarted();
-
-  scoped_ptr<ResourceUpdateQueue> queue(raw_queue);
-
   impl().commit_completion_event = completion;
-  impl().current_resource_update_controller = ResourceUpdateController::Create(
-      this,
-      Proxy::ImplThreadTaskRunner(),
-      queue.Pass(),
-      impl().layer_tree_host_impl->resource_provider());
-  impl().current_resource_update_controller->PerformMoreUpdates(
-      impl().scheduler->AnticipatedDrawTime());
+  impl().scheduler->NotifyReadyToCommit();
 }
 
 void ThreadProxy::BeginMainFrameAbortedOnImplThread(
     CommitEarlyOutReason reason) {
   TRACE_EVENT1("cc", "ThreadProxy::BeginMainFrameAbortedOnImplThread", "reason",
                CommitEarlyOutReasonToString(reason));
   DCHECK(IsImplThread());
   DCHECK(impl().scheduler);
   DCHECK(impl().scheduler->CommitPending());
   DCHECK(!impl().layer_tree_host_impl->pending_tree());
@@ skipping 27 matching lines @@
   if (!impl().layer_tree_host_impl->AnimationsAreVisible()) {
     impl().layer_tree_host_impl->UpdateAnimationState(true);
   }
 }
 
 void ThreadProxy::ScheduledActionCommit() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionCommit");
   DCHECK(IsImplThread());
   DCHECK(IsMainThreadBlocked());
   DCHECK(impl().commit_completion_event);
-  DCHECK(impl().current_resource_update_controller);
-
-  // Complete all remaining texture updates.
-  impl().current_resource_update_controller->Finalize();
-  impl().current_resource_update_controller = nullptr;
 
   blocked_main().main_thread_inside_commit = true;
   impl().layer_tree_host_impl->BeginCommit();
   layer_tree_host()->BeginCommitOnImplThread(impl().layer_tree_host_impl.get());
   layer_tree_host()->FinishCommitOnImplThread(
       impl().layer_tree_host_impl.get());
   blocked_main().main_thread_inside_commit = false;
 
   bool hold_commit = layer_tree_host()->settings().impl_side_painting &&
                      blocked_main().commit_waits_for_activation;
@@ skipping 126 matching lines @@
   bool forced_draw = true;
   return DrawSwapInternal(forced_draw);
 }
 
 void ThreadProxy::ScheduledActionInvalidateOutputSurface() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionInvalidateOutputSurface");
   DCHECK(impl().layer_tree_host_impl->output_surface());
   impl().layer_tree_host_impl->output_surface()->Invalidate();
 }
 
-void ThreadProxy::DidAnticipatedDrawTimeChange(base::TimeTicks time) {
-  if (impl().current_resource_update_controller)
-    impl().current_resource_update_controller->PerformMoreUpdates(time);
-}
-
 base::TimeDelta ThreadProxy::DrawDurationEstimate() {
   return impl().timing_history.DrawDurationEstimate();
 }
 
 base::TimeDelta ThreadProxy::BeginMainFrameToCommitDurationEstimate() {
   return impl().timing_history.BeginMainFrameToCommitDurationEstimate();
 }
 
 base::TimeDelta ThreadProxy::CommitToActivateDurationEstimate() {
   return impl().timing_history.CommitToActivateDurationEstimate();
 }
 
 void ThreadProxy::DidFinishImplFrame() {
   impl().layer_tree_host_impl->DidFinishImplFrame();
 }
 
 void ThreadProxy::SendBeginFramesToChildren(const BeginFrameArgs& args) {
   NOTREACHED() << "Only used by SingleThreadProxy";
 }
 
 void ThreadProxy::SetAuthoritativeVSyncInterval(
     const base::TimeDelta& interval) {
   NOTREACHED() << "Only used by SingleThreadProxy";
 }
 
-void ThreadProxy::ReadyToFinalizeTextureUpdates() {
-  DCHECK(IsImplThread());
-  impl().scheduler->NotifyReadyToCommit();
-}
-
 void ThreadProxy::DidCommitAndDrawFrame() {
   DCHECK(IsMainThread());
   layer_tree_host()->DidCommitAndDrawFrame();
 }
 
 void ThreadProxy::DidCompleteSwapBuffers() {
   DCHECK(IsMainThread());
   layer_tree_host()->DidCompleteSwapBuffers();
 }
 
@@ skipping 54 matching lines @@
     if (context_provider)
       context_provider->ContextGL()->Finish();
   }
   completion->Signal();
 }
 
 void ThreadProxy::LayerTreeHostClosedOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::LayerTreeHostClosedOnImplThread");
   DCHECK(IsImplThread());
   DCHECK(IsMainThreadBlocked());
-  impl().current_resource_update_controller = nullptr;
   impl().scheduler = nullptr;
   impl().layer_tree_host_impl = nullptr;
   impl().weak_factory.InvalidateWeakPtrs();
   // We need to explicitly shutdown the notifier to destroy any weakptrs it is
   // holding while still on the compositor thread. This also ensures any
   // callbacks holding a ThreadProxy pointer are cancelled.
   impl().smoothness_priority_expiration_notifier.Shutdown();
   completion->Signal();
 }
 
-size_t ThreadProxy::MaxPartialTextureUpdates() const {
-  return ResourceUpdateController::MaxPartialTextureUpdates();
-}
-
 ThreadProxy::BeginMainFrameAndCommitState::BeginMainFrameAndCommitState()
     : memory_allocation_limit_bytes(0),
       memory_allocation_priority_cutoff(0),
       evicted_ui_resources(false) {}
 
 ThreadProxy::BeginMainFrameAndCommitState::~BeginMainFrameAndCommitState() {}
 
 bool ThreadProxy::MainFrameWillHappenForTesting() {
   DCHECK(IsMainThread());
   CompletionEvent completion;
@@ skipping 130 matching lines @@
 
 void ThreadProxy::PostFrameTimingEvents(
     scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
   DCHECK(IsMainThread());
   layer_tree_host()->RecordFrameTimingEvents(composite_events.Pass(),
                                              main_frame_events.Pass());
 }
 
 }  // namespace cc