Refactor VideoStub interface to accept ownership of video packets.

remoting/host/chromoting_host_unittest.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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "remoting/jingle_glue/mock_objects.h"
 #include "remoting/host/capturer_fake.h"
 #include "remoting/host/chromoting_host.h"
@@ skipping 121 matching lines @@
     EXPECT_CALL(*session2_, Close())
         .Times(AnyNumber());
 
     owned_connection_.reset(new MockConnectionToClient(
         session_, &host_stub_, event_executor_));
     connection_ = owned_connection_.get();
     owned_connection2_.reset(new MockConnectionToClient(
         session2_, &host_stub2_, &event_executor2_));
     connection2_ = owned_connection2_.get();
 
-    ON_CALL(video_stub_, ProcessVideoPacket(_, _))
+    ON_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
         .WillByDefault(DeleteArg<0>());
-    ON_CALL(video_stub2_, ProcessVideoPacket(_, _))
+    ON_CALL(video_stub2_, ProcessVideoPacketPtr(_, _))
         .WillByDefault(DeleteArg<0>());
     ON_CALL(*connection_, video_stub())
         .WillByDefault(Return(&video_stub_));
     ON_CALL(*connection_, client_stub())
         .WillByDefault(Return(&client_stub_));
     ON_CALL(*connection_, session())
         .WillByDefault(Return(session_));
     ON_CALL(*connection2_, video_stub())
         .WillByDefault(Return(&video_stub2_));
     ON_CALL(*connection2_, client_stub())
@@ skipping 115 matching lines @@
 
 TEST_F(ChromotingHostTest, DISABLED_Connect) {
   host_->Start();
 
   // When the video packet is received we first shutdown ChromotingHost
   // then execute the done task.
   {
     InSequence s;
     EXPECT_CALL(*disconnect_window_, Show(_, _))
         .Times(0);
-    EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
+    EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
         .WillOnce(DoAll(
             InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost),
             RunDoneTask()))
         .RetiresOnSaturation();
-    EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
+    EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
         .Times(AnyNumber());
     EXPECT_CALL(*connection_, Disconnect())
         .RetiresOnSaturation();
   }
   SimulateClientConnection(0, true);
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, DISABLED_Reconnect) {
   host_->Start();
 
   // When the video packet is received we first disconnect the mock
   // connection.
   {
     InSequence s;
     EXPECT_CALL(*disconnect_window_, Show(_, _))
         .Times(0);
-    EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
+    EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
         .WillOnce(DoAll(
             InvokeWithoutArgs(this, &ChromotingHostTest::RemoveClientSession),
             RunDoneTask()))
         .RetiresOnSaturation();
-    EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
+    EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
         .Times(AnyNumber());
-    EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
+    EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
         .Times(AnyNumber());
   }
 
   // If Disconnect() is called we can break the main message loop.
   EXPECT_CALL(*connection_, Disconnect())
       .WillOnce(QuitMainMessageLoop(&message_loop_))
       .RetiresOnSaturation();
 
   SimulateClientConnection(0, true);
   message_loop_.Run();
 
   // Connect the client again.
   {
     InSequence s;
     EXPECT_CALL(*disconnect_window_, Show(_, _))
         .Times(0);
-    EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
+    EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
         .WillOnce(DoAll(
             InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost),
             RunDoneTask()))
         .RetiresOnSaturation();
-    EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
+    EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
         .Times(AnyNumber());
   }
 
   EXPECT_CALL(*connection_, Disconnect())
       .RetiresOnSaturation();
 
   SimulateClientConnection(0, true);
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, DISABLED_ConnectTwice) {
   host_->Start();
 
   // When a video packet is received we connect the second mock
   // connection.
   {
     InSequence s;
     EXPECT_CALL(*disconnect_window_, Show(_, _))
         .Times(0);
-    EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
+    EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
         .WillOnce(DoAll(
             InvokeWithoutArgs(
                 CreateFunctor(
                     this,
                     &ChromotingHostTest::SimulateClientConnection, 1, true)),
             RunDoneTask()))
         .RetiresOnSaturation();
     EXPECT_CALL(*disconnect_window_, Show(_, _))
         .Times(0);
-    EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
+    EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
         .Times(AnyNumber());
-    EXPECT_CALL(video_stub2_, ProcessVideoPacket(_, _))
+    EXPECT_CALL(video_stub2_, ProcessVideoPacketPtr(_, _))
         .WillOnce(DoAll(
             InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost),
             RunDoneTask()))
         .RetiresOnSaturation();
-    EXPECT_CALL(video_stub2_, ProcessVideoPacket(_, _))
+    EXPECT_CALL(video_stub2_, ProcessVideoPacketPtr(_, _))
         .Times(AnyNumber());
   }
 
   EXPECT_CALL(*connection_, Disconnect())
       .RetiresOnSaturation();
   EXPECT_CALL(*connection2_, Disconnect())
       .RetiresOnSaturation();
 
   SimulateClientConnection(0, true);
   message_loop_.Run();
 }
 
 }  // namespace remoting