Decouple browser-specific GPU IPC messages from GPU service IPCs

content/common/gpu/gpu_channel_test_common.cc

 // Copyright (c) 2015 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/gpu_channel_test_common.h"
 
 #include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
+#include "content/common/gpu/gpu_channel_manager_delegate.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "ipc/ipc_test_sink.h"
 
 namespace content {
 
+TestGpuChannelManagerDelegate::TestGpuChannelManagerDelegate() {}
+
+TestGpuChannelManagerDelegate::~TestGpuChannelManagerDelegate() {}
+
+void TestGpuChannelManagerDelegate::AddSubscription(int32_t client_id,
+                                                    unsigned int target) {}
+
+void TestGpuChannelManagerDelegate::ChannelEstablished(
+    const IPC::ChannelHandle& channel_handle) {
+  last_established_channel_handle_ = channel_handle;
+}
+
+void TestGpuChannelManagerDelegate::DidCreateOffscreenContext(
+    const GURL& active_url) {}
+
+void TestGpuChannelManagerDelegate::DidDestroyChannel(int client_id) {}
+
+void TestGpuChannelManagerDelegate::DidDestroyOffscreenContext(
+    const GURL& active_url) {}
+
+void TestGpuChannelManagerDelegate::DidLoseContext(
+    bool offscreen,
+    gpu::error::ContextLostReason reason,
+    const GURL& active_url) {}
+
+void TestGpuChannelManagerDelegate::GpuMemoryUmaStats(
+    const GPUMemoryUmaStats& params) {}
+
+void TestGpuChannelManagerDelegate::RemoveSubscription(int32_t client_id,
+                                                       unsigned int target) {}
+
+void TestGpuChannelManagerDelegate::StoreShaderToDisk(
+    int32_t client_id,
+    const std::string& key,
+    const std::string& shader) {}
+
 TestGpuChannelManager::TestGpuChannelManager(
     IPC::TestSink* sink,
+    GpuChannelManagerDelegate* delegate,
     base::SingleThreadTaskRunner* task_runner,
     base::SingleThreadTaskRunner* io_task_runner,
     gpu::SyncPointManager* sync_point_manager,
     GpuMemoryBufferFactory* gpu_memory_buffer_factory)
-    : GpuChannelManager(nullptr,
+    : GpuChannelManager(delegate,
+                        nullptr,
                         nullptr,
                         task_runner,
                         io_task_runner,
                         nullptr,
                         sync_point_manager,
                         gpu_memory_buffer_factory),
       sink_(sink) {}

[no sievers, 2016/02/19 19:46:23]

Isn't the |sink_| unused now too with everything going through the delegate?

[Fady Samuel, 2016/02/19 20:33:30]

It is used by the GpuChannel.

[no sievers, 2016/02/19 21:08:29]

Ah there is some confusion between the channels and everything goes through one
sink in the tests. It would probably make a bit more sense for each
TestGpuChannel to have a sink and then change the two call sites in
GpuChannelTest::HandleMessage() to call channel->sink() instead.

[Fady Samuel, 2016/02/20 02:53:08]

Done.

 
 TestGpuChannelManager::~TestGpuChannelManager() {
   // Clear gpu channels here so that any IPC messages sent are handled using the
   // overridden Send method.
   gpu_channels_.clear();
 }
 
-bool TestGpuChannelManager::Send(IPC::Message* msg) {
-  return sink_->Send(msg);
-}
-
 scoped_ptr<GpuChannel> TestGpuChannelManager::CreateGpuChannel(
     int client_id,
     uint64_t client_tracing_id,
     bool preempts,
     bool allow_view_command_buffers,
     bool allow_real_time_streams) {
   return make_scoped_ptr(new TestGpuChannel(
       sink_, this, sync_point_manager(), share_group(), mailbox_manager(),
       preempts ? preemption_flag() : nullptr, task_runner_.get(),
       io_task_runner_.get(), client_id, client_tracing_id,
@@ skipping 45 matching lines @@
   DCHECK(!msg->is_sync());
   return sink_->Send(msg);
 }
 
 // TODO(sunnyps): Use a mock memory buffer factory when necessary.
 GpuChannelTestCommon::GpuChannelTestCommon()
     : sink_(new IPC::TestSink),
       task_runner_(new base::TestSimpleTaskRunner),
       io_task_runner_(new base::TestSimpleTaskRunner),
       sync_point_manager_(new gpu::SyncPointManager(false)),
-      channel_manager_(new TestGpuChannelManager(sink_.get(),
-                                                 task_runner_.get(),
-                                                 io_task_runner_.get(),
-                                                 sync_point_manager_.get(),
-                                                 nullptr)) {}
+      channel_manager_delegate_(new TestGpuChannelManagerDelegate()),
+      channel_manager_(
+          new TestGpuChannelManager(sink_.get(),
+                                    channel_manager_delegate_.get(),
+                                    task_runner_.get(),
+                                    io_task_runner_.get(),
+                                    sync_point_manager_.get(),
+                                    nullptr)) {}
 
 GpuChannelTestCommon::~GpuChannelTestCommon() {}
 
 }  // namespace content