Define EncodedVideoSource and RtcCapturedEncodingVideoCapturer.

content/renderer/media/video_capture_impl_manager.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 "content/renderer/media/video_capture_impl_manager.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
+#include "content/renderer/media/rtc_encoding_video_capturer_factory.h"
 #include "content/renderer/media/video_capture_impl.h"
 #include "content/renderer/media/video_capture_message_filter.h"
 
 namespace content {
 
 VideoCaptureImplManager::VideoCaptureImplManager()
     : thread_("VC manager") {
   thread_.Start();
   message_loop_proxy_ = thread_.message_loop_proxy();
   filter_ = new VideoCaptureMessageFilter();
+
+#if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL)
+  encoding_capturer_factory_ = new RtcEncodingVideoCapturerFactory();

[Ami GONE FROM CHROMIUM, 2013/06/12 01:44:06]

Are you planning to hold off landing this CL until all the rest of the machinery
lands (sheu@'s CLs)?  Because if you don't, then this will break the use cases
in question on cros/arm.  I think you want a runtime flag.

[hshi1, 2013/06/12 17:52:39]

Theoretically this wouldn't "break" cros/arm, because if the browser-side is not
implemented then no encoding capabilities will be reported, thus no caps will be
exposed by the factory, and no external encoder would be created by libjingle,
and we'll never go through the rest of the EVS stuff.

But you're probably right that things could go unpredictably wrong with the
browser-side unimplemented. Will update later today.

+#endif
 }
 
 media::VideoCapture* VideoCaptureImplManager::AddDevice(
     media::VideoCaptureSessionId id,
     media::VideoCapture::EventHandler* handler) {
   DCHECK(handler);
 
   base::AutoLock auto_lock(lock_);
   Devices::iterator it = devices_.find(id);
   if (it == devices_.end()) {
     VideoCaptureImpl* vc =
         new VideoCaptureImpl(id, message_loop_proxy_.get(), filter_.get());
     devices_[id] = new Device(vc, handler);
     vc->Init();
+    if (encoding_capturer_factory_)
+      encoding_capturer_factory_->OnEncodedVideoSourceAdded(vc);
     return vc;
   }
 
   devices_[id]->clients.push_front(handler);
   return it->second->vc;
 }
 
 void VideoCaptureImplManager::SuspendDevices(bool suspend) {
   base::AutoLock auto_lock(lock_);
   for (Devices::iterator it = devices_.begin(); it != devices_.end(); ++it)
     it->second->vc->SuspendCapture(suspend);
 }
 
 void VideoCaptureImplManager::RemoveDevice(
     media::VideoCaptureSessionId id,
     media::VideoCapture::EventHandler* handler) {
   DCHECK(handler);
 
   base::AutoLock auto_lock(lock_);
   Devices::iterator it = devices_.find(id);
   if (it == devices_.end())
     return;
 
   size_t size = it->second->clients.size();
   it->second->clients.remove(handler);
 
   if (size == it->second->clients.size() || size > 1)
     return;
 
+  if (encoding_capturer_factory_)
+    encoding_capturer_factory_->OnEncodedVideoSourceRemoved(devices_[id]->vc);
+
   devices_[id]->vc->DeInit(base::Bind(&VideoCaptureImplManager::FreeDevice,
                                       this, devices_[id]->vc));
   delete devices_[id];
   devices_.erase(id);
 }
 
 void VideoCaptureImplManager::FreeDevice(VideoCaptureImpl* vc) {
   delete vc;
 }
 
 VideoCaptureImplManager::~VideoCaptureImplManager() {
   thread_.Stop();
   // TODO(wjia): uncomment the line below after collecting enough info for
   // crbug.com/152418.
   // STLDeleteContainerPairSecondPointers(devices_.begin(), devices_.end());
 }
 
 VideoCaptureImplManager::Device::Device(
     VideoCaptureImpl* device,
     media::VideoCapture::EventHandler* handler)
     : vc(device) {
   clients.push_front(handler);
 }
 
 VideoCaptureImplManager::Device::~Device() {}
 
 }  // namespace content