Simplify VideoEncoder interface.

remoting/host/video_scheduler_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 "remoting/host/video_scheduler.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "remoting/base/auto_thread_task_runner.h"
@@ skipping 20 matching lines @@
 using ::testing::ReturnRef;
 using ::testing::SaveArg;
 
 namespace remoting {
 
 namespace {
 
 ACTION(FinishEncode) {
   scoped_ptr<VideoPacket> packet(new VideoPacket());
   packet->set_flags(VideoPacket::LAST_PACKET | VideoPacket::LAST_PARTITION);
-  arg1.Run(packet.Pass());
+  return packet.release();
 }
 
 ACTION(FinishSend) {
   arg1.Run();
 }
 
 }  // namespace
 
 static const int kWidth = 640;
 static const int kHeight = 480;
 
 class MockVideoEncoder : public VideoEncoder {
  public:
   MockVideoEncoder();
   virtual ~MockVideoEncoder();
 
-  MOCK_METHOD2(Encode, void(
-      const webrtc::DesktopFrame* frame,
-      const DataAvailableCallback& data_available_callback));
+  scoped_ptr<VideoPacket> Encode(
+      const webrtc::DesktopFrame& frame) {
+    return scoped_ptr<VideoPacket>(EncodePtr(frame));
+  }
+  MOCK_METHOD1(EncodePtr, VideoPacket*(const webrtc::DesktopFrame& frame));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockVideoEncoder);
 };
 
 MockVideoEncoder::MockVideoEncoder() {}
 
 MockVideoEncoder::~MockVideoEncoder() {}
 
 class VideoSchedulerTest : public testing::Test {
@@ skipping 80 matching lines @@
 // sequence to be executed successfully.
 TEST_F(VideoSchedulerTest, StartAndStop) {
   scoped_ptr<webrtc::MockScreenCapturer> capturer(
       new webrtc::MockScreenCapturer());
   Expectation capturer_start =
       EXPECT_CALL(*capturer, Start(_))
           .WillOnce(Invoke(this, &VideoSchedulerTest::OnCapturerStart));
 
   frame_.reset(new webrtc::BasicDesktopFrame(
       webrtc::DesktopSize(kWidth, kHeight)));
-  webrtc::DesktopFrame* frame_ptr = frame_.get();
 
   // First the capturer is called.
   Expectation capturer_capture = EXPECT_CALL(*capturer, Capture(_))
       .After(capturer_start)
       .WillRepeatedly(Invoke(this, &VideoSchedulerTest::OnCaptureFrame));
 
   // Expect the encoder be called.
-  EXPECT_CALL(*encoder_, Encode(frame_ptr, _))
+  EXPECT_CALL(*encoder_, EncodePtr(_))
       .WillRepeatedly(FinishEncode());
 
   // By default delete the arguments when ProcessVideoPacket is received.
   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
       .WillRepeatedly(FinishSend());
 
   // For the first time when ProcessVideoPacket is received we stop the
   // VideoScheduler.
   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
       .WillOnce(DoAll(
           FinishSend(),
           InvokeWithoutArgs(this, &VideoSchedulerTest::StopVideoScheduler)))
       .RetiresOnSaturation();
 
   // Start video frame capture.
   StartVideoScheduler(capturer.PassAs<webrtc::ScreenCapturer>());
 
   task_runner_ = NULL;
   run_loop_.Run();
 }
 
 }  // namespace remoting