Remove old texture path in TextureLayer

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 76 matching lines @@
 }
 
 ThreadProxy::MainThreadOnly::MainThreadOnly(ThreadProxy* proxy,
                                             int layer_tree_host_id)
     : layer_tree_host_id(layer_tree_host_id),
       animate_requested(false),
       commit_requested(false),
       commit_request_sent_to_impl_thread(false),
       created_offscreen_context_provider(false),
       started(false),
-      textures_acquired(true),
       in_composite_and_readback(false),
       manage_tiles_pending(false),
       can_cancel_commit(true),
       defer_commits(false),
       weak_factory(proxy) {}
 
 ThreadProxy::MainThreadOnly::~MainThreadOnly() {}
 
 ThreadProxy::MainThreadOrBlockedMainThread::MainThreadOrBlockedMainThread(
     LayerTreeHost* host)
     : layer_tree_host(host),
       commit_waits_for_activation(false),
       main_thread_inside_commit(false) {}
 
 ThreadProxy::MainThreadOrBlockedMainThread::~MainThreadOrBlockedMainThread() {}
 
 PrioritizedResourceManager*
 ThreadProxy::MainThreadOrBlockedMainThread::contents_texture_manager() {
   return layer_tree_host->contents_texture_manager();
 }
 
 ThreadProxy::CompositorThreadOnly::CompositorThreadOnly(ThreadProxy* proxy,
                                                         int layer_tree_host_id)
     : layer_tree_host_id(layer_tree_host_id),
       contents_texture_manager(NULL),
       begin_main_frame_sent_completion_event(NULL),
       readback_request(NULL),
       commit_completion_event(NULL),
       completion_event_for_commit_held_on_tree_activation(NULL),
-      texture_acquisition_completion_event(NULL),
       next_frame_is_newly_committed_frame(false),
       inside_draw(false),
       input_throttled_until_commit(false),
       animations_frozen_until_next_draw(false),
       renew_tree_priority_pending(false),
       weak_factory(proxy) {}
 
 ThreadProxy::CompositorThreadOnly::~CompositorThreadOnly() {}
 
 ThreadProxy::~ThreadProxy() {
@@ skipping 771 matching lines @@
   bool can_cancel_this_commit = main().can_cancel_commit &&
                                 !main().in_composite_and_readback &&
                                 !evicted_ui_resources;
   main().can_cancel_commit = true;
 
   scoped_ptr<ResourceUpdateQueue> queue =
       make_scoped_ptr(new ResourceUpdateQueue);
 
   bool updated = layer_tree_host()->UpdateLayers(queue.get());
 
-  // Once single buffered layers are committed, they cannot be modified until
-  // they are drawn by the impl thread.
-  main().textures_acquired = false;
-
   layer_tree_host()->WillCommit();
 
   // 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
   // thread.
   if (main().animate_requested) {
     // Forces SetNeedsAnimate to consider posting a commit task.
     main().animate_requested = false;
@@ skipping 360 matching lines @@
                                draw_duration_overestimate,
                                base::TimeDelta::FromMilliseconds(1),
                                base::TimeDelta::FromMilliseconds(100),
                                50);
   }
 
   DCHECK_NE(DrawSwapReadbackResult::INVALID_RESULT, result.draw_result);
   return result;
 }
 
-void ThreadProxy::AcquireLayerTextures() {
-  // Called when the main thread needs to modify a layer texture that is used
-  // directly by the compositor.
-  // This method will block until the next compositor draw if there is a
-  // previously committed frame that is still undrawn. This is necessary to
-  // ensure that the main thread does not monopolize access to the textures.
-  DCHECK(IsMainThread());
-
-  if (main().textures_acquired)
-    return;
-
-  TRACE_EVENT0("cc", "ThreadProxy::AcquireLayerTextures");
-  DebugScopedSetMainThreadBlocked main_thread_blocked(this);
-  CompletionEvent completion;
-  Proxy::ImplThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::AcquireLayerTexturesForMainThreadOnImplThread,
-                 impl_thread_weak_ptr_,
-                 &completion));
-  // Block until it is safe to write to layer textures from the main thread.
-  completion.Wait();
-
-  main().textures_acquired = true;
-  main().can_cancel_commit = false;
-}
-
-void ThreadProxy::AcquireLayerTexturesForMainThreadOnImplThread(
-    CompletionEvent* completion) {
-  DCHECK(IsImplThread());
-  DCHECK(!impl().texture_acquisition_completion_event);
-
-  impl().texture_acquisition_completion_event = completion;
-  impl().scheduler->SetMainThreadNeedsLayerTextures();
-}
-
-void ThreadProxy::ScheduledActionAcquireLayerTexturesForMainThread() {
-  DCHECK(impl().texture_acquisition_completion_event);
-  impl().texture_acquisition_completion_event->Signal();
-  impl().texture_acquisition_completion_event = NULL;
-}
-
 void ThreadProxy::ScheduledActionManageTiles() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionManageTiles");
   DCHECK(impl().layer_tree_host_impl->settings().impl_side_painting);
   impl().layer_tree_host_impl->ManageTiles();
 }
 
 DrawSwapReadbackResult ThreadProxy::ScheduledActionDrawAndSwapIfPossible() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionDrawAndSwap");
 
   // SchedulerStateMachine::DidDrawIfPossibleCompleted isn't set up to
@@ skipping 387 matching lines @@
 
   impl().timing_history.DidActivatePendingTree();
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidManageTiles();
 }
 
 }  // namespace cc