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

blimp/engine/browser/engine_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/engine/browser/engine_render_widget_message_processor.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/numerics/safe_conversions.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/input_message_generator.h"
+#include "blimp/net/test_common.h"
 #include "net/base/net_errors.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebInputEvent.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 MockHostRenderWidgetMessageDelegate
     : public EngineRenderWidgetMessageProcessor::RenderWidgetMessageDelegate {
  public:
   // EngineRenderWidgetMessageProcessor implementation.
   void OnWebInputEvent(scoped_ptr<blink::WebInputEvent> event) override {
     MockableOnWebInputEvent();
   }
 
   void OnCompositorMessageReceived(
@@ skipping 104 matching lines @@
 }
 
 TEST_F(EngineRenderWidgetMessageProcessorTest, DropsStaleMessages) {
   std::vector<uint8_t> payload = { 'f', 'u', 'n' };
 
   EXPECT_CALL(delegate1_, MockableOnCompositorMessageReceived(
       CompMsgEquals(payload))).Times(1);
   SendCompositorMessage(&processor_, 1, 1U, payload);
 
   EXPECT_CALL(out_processor_,
-              MockableProcessMessage(BlimpRWMsgEquals(1, 2U))).Times(1);
+              MockableProcessMessage(BlimpRWMsgEquals(1, 2U), _)).Times(1);
   processor_.OnRenderWidgetInitialized(1);
 
   EXPECT_CALL(delegate1_, MockableOnCompositorMessageReceived(
       CompMsgEquals(payload))).Times(0);
   payload[0] = 'a';
   SendCompositorMessage(&processor_, 1, 1U, payload);
 
   EXPECT_CALL(delegate1_, MockableOnWebInputEvent()).Times(0);
   SendInputMessage(&processor_, 1, 1U);
 
   EXPECT_CALL(delegate1_, MockableOnCompositorMessageReceived(
       CompMsgEquals(payload))).Times(1);
   SendCompositorMessage(&processor_, 1, 2U, payload);
 
   EXPECT_CALL(delegate1_, MockableOnWebInputEvent()).Times(1);
   SendInputMessage(&processor_, 1, 2U);
 }
 
 TEST_F(EngineRenderWidgetMessageProcessorTest,
        RepliesHaveCorrectRenderWidgetId) {
   std::vector<uint8_t> payload = { 'a', 'b', 'c', 'd' };
 
   EXPECT_CALL(out_processor_,
-              MockableProcessMessage(BlimpRWMsgEquals(1, 2U))).Times(1);
+              MockableProcessMessage(BlimpRWMsgEquals(1, 2U), _)).Times(1);
   processor_.OnRenderWidgetInitialized(1);
 
   EXPECT_CALL(out_processor_,
-              MockableProcessMessage(BlimpRWMsgEquals(2, 2U))).Times(1);
+              MockableProcessMessage(BlimpRWMsgEquals(2, 2U), _)).Times(1);
   processor_.OnRenderWidgetInitialized(2);
 
   EXPECT_CALL(out_processor_, MockableProcessMessage(
-      BlimpCompMsgEquals(1, 2U, payload))).Times(1);
+      BlimpCompMsgEquals(1, 2U, payload), _)).Times(1);
 
   processor_.SendCompositorMessage(1, payload);
 }
 
 
 }  // namespace blimp