Add decode() functionality to image elements.

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/memory/ptr_util.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 189 matching lines @@
     layer_tree_host_impl_->BeginCommit();
 
     if (layer_tree_host_impl_->EvictedUIResourcesExist())
       layer_tree_host_->GetUIResourceManager()->RecreateUIResources();
 
     layer_tree_host_->FinishCommitOnImplThread(layer_tree_host_impl_.get());
 
     if (scheduler_on_impl_thread_)
       scheduler_on_impl_thread_->DidCommit();
 
-    // Issue decode callbacks.
-    auto completed_decode_callbacks =
-        layer_tree_host_impl_->TakeCompletedImageDecodeCallbacks();
-    for (auto& callback : completed_decode_callbacks)
-      callback.Run();
-
+    IssueImageDecodeFinishedCallbacks();
     layer_tree_host_impl_->CommitComplete();
 
     // 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();
   }
 }
 
+void SingleThreadProxy::IssueImageDecodeFinishedCallbacks() {
+  DCHECK(task_runner_provider_->IsImplThread());
+
+  auto completed_decode_callbacks =
+      layer_tree_host_impl_->TakeCompletedImageDecodeCallbacks();
+  for (auto& callback : completed_decode_callbacks)
+    callback.Run();
+}
+
 void SingleThreadProxy::CommitComplete() {
   // Commit complete happens on the main side after activate to satisfy any
   // SetNextCommitWaitsForActivation calls.
   DCHECK(!layer_tree_host_impl_->pending_tree())
       << "Activation is expected to have synchronously occurred by now.";
   DCHECK(commit_blocking_task_runner_);
 
   DebugScopedSetMainThread main(task_runner_provider_);
   commit_blocking_task_runner_.reset();
   layer_tree_host_->CommitComplete();
@@ skipping 202 matching lines @@
 void SingleThreadProxy::OnDrawForCompositorFrameSink(
     bool resourceless_software_draw) {
   NOTREACHED() << "Implemented by ThreadProxy for synchronous compositor.";
 }
 
 void SingleThreadProxy::NeedsImplSideInvalidation() {
   DCHECK(scheduler_on_impl_thread_);
   scheduler_on_impl_thread_->SetNeedsImplSideInvalidation();
 }
 
+void SingleThreadProxy::NotifyImageDecodeRequestFinished() {
+  // If we don't have a scheduler, then just issue the callbacks here.
+  // Otherwise, schedule a commit.
+  if (!scheduler_on_impl_thread_) {
+    DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_);
+    DebugScopedSetImplThread impl(task_runner_provider_);
+
+    IssueImageDecodeFinishedCallbacks();
+    return;
+  }
+  SetNeedsCommitOnImplThread();
+}
+
 void SingleThreadProxy::CompositeImmediately(base::TimeTicks frame_begin_time) {
   TRACE_EVENT0("cc,benchmark", "SingleThreadProxy::CompositeImmediately");
   DCHECK(task_runner_provider_->IsMainThread());
 #if DCHECK_IS_ON()
   DCHECK(!inside_impl_frame_);
 #endif
   base::AutoReset<bool> inside_composite(&inside_synchronous_composite_, true);
 
   if (compositor_frame_sink_lost_) {
     RequestNewCompositorFrameSink();
@@ skipping 351 matching lines @@
 void SingleThreadProxy::DidNotProduceFrame(const BeginFrameAck& ack) {
   DebugScopedSetImplThread impl(task_runner_provider_);
   layer_tree_host_impl_->DidNotProduceFrame(ack);
 }
 
 void SingleThreadProxy::DidReceiveCompositorFrameAck() {
   layer_tree_host_->DidReceiveCompositorFrameAck();
 }
 
 }  // namespace cc