Move blimp/net/test_common.h/cc to a separate source_set.

blimp/client/compositor/render_widget_message_processor_unittest.cc

 // Copyright 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 "blimp/client/compositor/render_widget_message_processor.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "blimp/common/proto/blimp_message.pb.h"
 #include "blimp/common/proto/compositor.pb.h"
 #include "blimp/common/proto/render_widget.pb.h"
+#include "blimp/net/test_common.h"
 #include "cc/proto/compositor_message.pb.h"
 #include "net/base/net_errors.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::InvokeArgument;
 using testing::Ref;
 using testing::Return;
 using testing::SaveArg;
 
 namespace blimp {
 
 namespace {
-class MockBlimpMessageProcessor : public BlimpMessageProcessor {
- public:
-  MockBlimpMessageProcessor() {}
-
-  ~MockBlimpMessageProcessor() override {}
-
-  // Adapts calls from ProcessMessage to MockableProcessMessage by
-  // unboxing the |message| scoped_ptr for GMock compatibility.
-  void ProcessMessage(scoped_ptr<BlimpMessage> message,
-                      const net::CompletionCallback& callback) {
-    MockableProcessMessage(*message);
-    if (!callback.is_null())
-      callback.Run(net::OK);
-  }
-
-  MOCK_METHOD1(MockableProcessMessage,
-               void(const BlimpMessage& message));
-};
 
 class MockRenderWidgetMessageDelegate
     : public RenderWidgetMessageProcessor::RenderWidgetMessageDelegate {
  public:
   // RenderWidgetMessageDelegate implementation.
   void OnRenderWidgetInitialized() override {
     MockableOnRenderWidgetInitialized();
   }
   void OnCompositorMessageReceived(
       scoped_ptr<cc::proto::CompositorMessage> message) override {
@@ skipping 69 matching lines @@
 
   EXPECT_CALL(delegate2_, MockableOnCompositorMessageReceived(_)).Times(1);
   SendCompositorMessage(&processor_, 2, 2U);
 }
 
 TEST_F(RenderWidgetMessageProcessorTest, RepliesHaveCorrectRenderWidgetId) {
   SendRenderWidgetMessage(&processor_, 1, 2U);
   SendRenderWidgetMessage(&processor_, 2, 1U);
 
   EXPECT_CALL(out_processor_,
-              MockableProcessMessage(CompMsgEquals(1, 2U))).Times(1);
+              MockableProcessMessage(CompMsgEquals(1, 2U), _)).Times(1);
   processor_.SendCompositorMessage(1, cc::proto::CompositorMessage());
 
   SendRenderWidgetMessage(&processor_, 1, 3U);
 
   EXPECT_CALL(out_processor_,
-              MockableProcessMessage(CompMsgEquals(1, 3U))).Times(1);
+              MockableProcessMessage(CompMsgEquals(1, 3U), _)).Times(1);
   processor_.SendCompositorMessage(1, cc::proto::CompositorMessage());
 
   EXPECT_CALL(out_processor_,
-              MockableProcessMessage(CompMsgEquals(2, 1U))).Times(1);
+              MockableProcessMessage(CompMsgEquals(2, 1U), _)).Times(1);
   processor_.SendCompositorMessage(2, cc::proto::CompositorMessage());
 }
 
 }  // namespace blimp