Decouple PassThroughImageTransportSurface from GpuCommandBufferStub

gpu/ipc/service/gpu_command_buffer_stub.cc

 // Copyright (c) 2012 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 "gpu/ipc/service/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 257 matching lines @@
         base::TimeDelta::FromMilliseconds(kHandleMoreWorkPeriodMs));
   }
 
   return handled;
 }
 
 bool GpuCommandBufferStub::Send(IPC::Message* message) {
   return channel_->Send(message);
 }
 
+void GpuCommandBufferStub::DidSwapBuffersComplete(
+    SwapBuffersCompleteParams params) {
+  GpuCommandBufferMsg_SwapBuffersCompleted_Params send_params;
+#if defined(OS_MACOSX)
+  send_params.ca_context_id = params.ca_context_id;
+  send_params.fullscreen_low_power_ca_context_valid =
+      params.fullscreen_low_power_ca_context_valid;
+  send_params.io_surface = params.io_surface;
+  send_params.pixel_size = params.pixel_size;
+  send_params.scale_factor = params.scale_factor;
+  send_params.in_use_responses = params.in_use_responses;
+#endif
+  send_params.latency_info = std::move(params.latency_info);
+  send_params.result = params.result;
+  Send(new GpuCommandBufferMsg_SwapBuffersCompleted(route_id_, send_params));
+}
+
+const gles2::FeatureInfo* GpuCommandBufferStub::GetFeatureInfo() const {
+  return context_group_->feature_info();
+}
+
+void GpuCommandBufferStub::SetLatencyInfoCallback(
+    const LatencyInfoCallback& callback) {
+  latency_info_callback_ = callback;
+}
+
+void GpuCommandBufferStub::UpdateVSyncParameters(base::TimeTicks timebase,
+                                                 base::TimeDelta interval) {
+  Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
+                                                     interval));
+}
+
 bool GpuCommandBufferStub::IsScheduled() {
   return (!executor_.get() || executor_->scheduled());
 }
 
 void GpuCommandBufferStub::PollWork() {
   // Post another delayed task if we have not yet reached the time at which
   // we should process delayed work.
   base::TimeTicks current_time = base::TimeTicks::Now();
   DCHECK(!process_delayed_work_time_.is_null());
   if (process_delayed_work_time_ > current_time) {
@@ skipping 229 matching lines @@
       CommandBufferNamespace::GPU_IO, command_buffer_id_);
 
   executor_->SetPreemptByFlag(channel_->preempted_flag());
 
   decoder_->set_engine(executor_.get());
 
   if (offscreen) {
     surface_ = default_surface;
   } else {
     surface_ = ImageTransportSurface::CreateNativeSurface(
-        manager, this, surface_handle_, surface_format);
+        manager, AsWeakPtr(), surface_handle_, surface_format);
     if (!surface_ || !surface_->Initialize(surface_format)) {
       surface_ = nullptr;
       DLOG(ERROR) << "Failed to create surface.";
       return false;
     }
   }
 
   scoped_refptr<gl::GLContext> context;
   gl::GLShareGroup* gl_share_group = channel_->share_group();
   if (use_virtualized_gl_context_ && gl_share_group) {
@@ skipping 109 matching lines @@
 void GpuCommandBufferStub::OnCreateStreamTexture(uint32_t texture_id,
                                                  int32_t stream_id,
                                                  bool* succeeded) {
 #if defined(OS_ANDROID)
   *succeeded = StreamTexture::Create(this, texture_id, stream_id);
 #else
   *succeeded = false;
 #endif
 }
 
-void GpuCommandBufferStub::SetLatencyInfoCallback(
-    const LatencyInfoCallback& callback) {
-  latency_info_callback_ = callback;
-}
-
 void GpuCommandBufferStub::OnSetGetBuffer(int32_t shm_id,
                                           IPC::Message* reply_message) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSetGetBuffer");
   if (command_buffer_)
     command_buffer_->SetGetBuffer(shm_id);
   Send(reply_message);
 }
 
 void GpuCommandBufferStub::OnTakeFrontBuffer(const Mailbox& mailbox) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnTakeFrontBuffer");
@@ skipping 382 matching lines @@
 void GpuCommandBufferStub::AddDestructionObserver(
     DestructionObserver* observer) {
   destruction_observers_.AddObserver(observer);
 }
 
 void GpuCommandBufferStub::RemoveDestructionObserver(
     DestructionObserver* observer) {
   destruction_observers_.RemoveObserver(observer);
 }
 
-const gles2::FeatureInfo* GpuCommandBufferStub::GetFeatureInfo() const {
-  return context_group_->feature_info();
-}
-
 gles2::MemoryTracker* GpuCommandBufferStub::GetMemoryTracker() const {
   return context_group_->memory_tracker();
 }
 
 bool GpuCommandBufferStub::CheckContextLost() {
   DCHECK(command_buffer_);
   CommandBuffer::State state = command_buffer_->GetLastState();
   bool was_lost = state.error == error::kLostContext;
 
   if (was_lost) {
@@ skipping 23 matching lines @@
   if (!command_buffer_ ||
       command_buffer_->GetLastState().error == error::kLostContext)
     return;
 
   command_buffer_->SetContextLostReason(error::kUnknown);
   if (decoder_)
     decoder_->MarkContextLost(error::kUnknown);
   command_buffer_->SetParseError(error::kLostContext);
 }
 
-void GpuCommandBufferStub::SendSwapBuffersCompleted(
-    const GpuCommandBufferMsg_SwapBuffersCompleted_Params& params) {
-  Send(new GpuCommandBufferMsg_SwapBuffersCompleted(route_id_, params));
-}
-
-void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
-                                                     base::TimeDelta interval) {
-  Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
-                                                     interval));
-}
-
 }  // namespace gpu