Provide TaskRunner to ContextCacheController

content/common/gpu/client/context_provider_command_buffer.cc

 // Copyright (c) 2013 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 "content/common/gpu/client/context_provider_command_buffer.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
@@ skipping 140 matching lines @@
     }
 
     // This command buffer is a client-side proxy to the command buffer in the
     // GPU process.
     scoped_refptr<base::SingleThreadTaskRunner> task_runner =
         default_task_runner_;
     if (!task_runner)
       task_runner = base::ThreadTaskRunnerHandle::Get();
     command_buffer_ = gpu::CommandBufferProxyImpl::Create(
         std::move(channel_), surface_handle_, shared_command_buffer, stream_id_,
-        stream_priority_, attributes_, active_url_, std::move(task_runner));
+        stream_priority_, attributes_, active_url_, task_runner);
     if (!command_buffer_) {
       DLOG(ERROR) << "GpuChannelHost failed to create command buffer.";
       command_buffer_metrics::UmaRecordContextInitFailed(context_type_);
       return false;
     }
 
     // The GLES2 helper writes the command buffer protocol.
     gles2_helper_.reset(new gpu::gles2::GLES2CmdHelper(command_buffer_.get()));
     gles2_helper_->SetAutomaticFlushes(automatic_flushes_);
     if (!gles2_helper_->Initialize(memory_limits_.command_buffer_size)) {
@@ skipping 37 matching lines @@
     // GpuChannelHost. Once that has happened, the service knows we are in the
     // share group and if a shared context is lost, our context will be informed
     // also, and the lost context callback will occur for the owner of the
     // context provider. If we check sooner, the shared context may be lost in
     // between these two states and our context here would be left in an orphan
     // share group.
     if (share_group && share_group->IsLost())
       return false;
 
     shared_providers_->list.push_back(this);
+
+    cache_controller_.reset(new cc::ContextCacheController(
+        gles2_impl_.get(), std::move(task_runner)));
   }
   set_bind_failed.Reset();
   bind_succeeded_ = true;
 
   gles2_impl_->SetLostContextCallback(
       base::Bind(&ContextProviderCommandBuffer::OnLostContext,
                  // |this| owns the GLES2Implementation which holds the
                  // callback.
                  base::Unretained(this)));
 
-  cache_controller_.reset(new cc::ContextCacheController(gles2_impl_.get()));
-
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableGpuClientTracing)) {
     // This wraps the real GLES2Implementation and we should always use this
     // instead when it's present.
     trace_impl_.reset(
         new gpu::gles2::GLES2TraceImplementation(gles2_impl_.get()));
   }
 
   // Do this last once the context is set up.
   std::string type_name =
@@ skipping 92 matching lines @@
 
 void ContextProviderCommandBuffer::SetLostContextCallback(
     const LostContextCallback& lost_context_callback) {
   DCHECK(context_thread_checker_.CalledOnValidThread());
   DCHECK(lost_context_callback_.is_null() ||
          lost_context_callback.is_null());
   lost_context_callback_ = lost_context_callback;
 }
 
 }  // namespace content