Hook up EncodedVideoSource on the browser side

content/browser/renderer_host/media/video_capture_manager_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.
 
 // Unit test for VideoCaptureManager.
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/media/media_stream_provider.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/media_stream_options.h"
+#include "media/base/encoded_bitstream_buffer.h"
 #include "media/video/capture/video_capture_device.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::InSequence;
 using testing::SaveArg;
 using ::testing::Return;
 
 namespace content {
 
 // Listener class used to track progress of VideoCaptureManager test.
 class MockMediaStreamProviderListener : public MediaStreamProviderListener {
  public:
   MockMediaStreamProviderListener() {}
   ~MockMediaStreamProviderListener() {}
 
   MOCK_METHOD2(Opened, void(MediaStreamType, int));
   MOCK_METHOD2(Closed, void(MediaStreamType, int));
   MOCK_METHOD2(DevicesEnumerated, void(MediaStreamType,
                                        const StreamDeviceInfoArray&));
   MOCK_METHOD3(Error, void(MediaStreamType, int,
                            MediaStreamProviderError));
 };  // class MockMediaStreamProviderListener
 
 // Needed as an input argument to Start().
 class MockFrameObserver : public media::VideoCaptureDevice::EventHandler {
  public:
-  virtual scoped_refptr<media::VideoFrame> ReserveOutputBuffer() OVERRIDE {
+  virtual scoped_refptr<media::VideoFrame> ReserveOutputVideoFrame() OVERRIDE {
+    return NULL;
+  }
+  virtual scoped_refptr<media::EncodedBitstreamBuffer>
+  ReserveOutputEncodedBitstreamBuffer() OVERRIDE {
     return NULL;
   }
   virtual void OnError() OVERRIDE {}
   virtual void OnFrameInfo(
       const media::VideoCaptureCapability& info) OVERRIDE {}
+  virtual void OnEncodedFrameInfo(
+      const media::VideoEncodingParameters& parameters) OVERRIDE {}
   virtual void OnIncomingCapturedFrame(const uint8* data,
                                        int length,
                                        base::Time timestamp,
                                        int rotation,
                                        bool flip_vert,
                                        bool flip_horiz) OVERRIDE {}
+  virtual void OnBitstreamConfigChanged(
+      const media::RuntimeVideoEncodingParameters& params) OVERRIDE {}
   virtual void OnIncomingCapturedVideoFrame(
       const scoped_refptr<media::VideoFrame>& frame,
       base::Time timestamp) OVERRIDE {}
+  virtual void OnIncomingCapturedEncodedBitstreamBuffer(
+      const scoped_refptr<media::EncodedBitstreamBuffer>& buffer,
+      size_t data_size,
+      base::Time timestamp) OVERRIDE {}
 };
 
 // Test class
 class VideoCaptureManagerTest : public testing::Test {
  public:
   VideoCaptureManagerTest() {}
   virtual ~VideoCaptureManagerTest() {}
 
  protected:
   virtual void SetUp() OVERRIDE {
@@ skipping 192 matching lines @@
   // VideoCaptureManager destructor otherwise.
   vcm_->Close(video_session_id);
   vcm_->Stop(video_session_id, base::Closure());
 
   // Wait to check callbacks before removing the listener
   message_loop_->RunUntilIdle();
   vcm_->Unregister();
 }
 
 }  // namespace content