Hook up EncodedVideoSource on the browser side

content/browser/renderer_host/media/video_capture_controller.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/browser/renderer_host/media/video_capture_controller.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/public/browser/browser_thread.h"
+#include "media/base/encoded_bitstream_buffer.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/base/yuv_convert.h"
 
 #if !defined(OS_IOS) && !defined(OS_ANDROID)
 #include "third_party/libyuv/include/libyuv.h"
 #endif
 
 namespace {
 
@@ skipping 54 matching lines @@
 
   // State of capture session, controlled by VideoCaptureManager directly.
   bool session_closed;
 };
 
 VideoCaptureController::VideoCaptureController(
     VideoCaptureManager* video_capture_manager)
     : chopped_width_(0),
       chopped_height_(0),
       frame_info_available_(false),
+      encoded_frame_info_available_(false),
       video_capture_manager_(video_capture_manager),
       device_in_use_(false),
       state_(VIDEO_CAPTURE_STATE_STOPPED) {
   memset(&current_params_, 0, sizeof(current_params_));
 }
 
 void VideoCaptureController::StartCapture(
     const VideoCaptureControllerID& id,
     VideoCaptureControllerEventHandler* event_handler,
     base::ProcessHandle render_process,
@@ skipping 23 matching lines @@
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
   // TODO(wjia): Temporarily disable restarting till client supports resampling.
 #if 0
     // This client has higher resolution than what is currently requested.
     // Need restart capturing.
     if (params.width > current_params_.width ||
         params.height > current_params_.height) {
       video_capture_manager_->Stop(current_params_.session_id,
           base::Bind(&VideoCaptureController::OnDeviceStopped, this));
       frame_info_available_ = false;
+      encoded_frame_info_available_ = false;
       state_ = VIDEO_CAPTURE_STATE_STOPPING;
       pending_clients_.push_back(client);
       return;
     }
 #endif
 
     // This client's resolution is no larger than what's currently requested.
     // When frame_info has been returned by device, send them to client.
-    if (frame_info_available_) {
+    if (frame_info_available_ || encoded_frame_info_available_) {
       SendFrameInfoAndBuffers(client);
     }
     controller_clients_.push_back(client);
     return;
   }
 
   // In case the device is in the middle of stopping, put the client in
   // pending queue.
   if (state_ == VIDEO_CAPTURE_STATE_STOPPING) {
     pending_clients_.push_back(client);
@@ skipping 41 matching lines @@
   delete client;
   controller_clients_.remove(client);
 
   // No more clients. Stop device.
   if (controller_clients_.empty() &&
       (state_ == VIDEO_CAPTURE_STATE_STARTED ||
        state_ == VIDEO_CAPTURE_STATE_ERROR)) {
     video_capture_manager_->Stop(session_id,
         base::Bind(&VideoCaptureController::OnDeviceStopped, this));
     frame_info_available_ = false;
+    encoded_frame_info_available_ = false;
     state_ = VIDEO_CAPTURE_STATE_STOPPING;
   }
 }
 
 void VideoCaptureController::StopSession(
     int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "VideoCaptureController::StopSession, id " << session_id;
 
   ControllerClient* client = FindClient(session_id, pending_clients_);
@@ skipping 26 matching lines @@
 
   // When all buffers have been returned by clients and device has been
   // called to stop, check if restart is needed. This could happen when
   // capture needs to be restarted due to resolution change.
   if (!buffer_pool_->IsAnyBufferHeldForConsumers() &&
       state_ == VIDEO_CAPTURE_STATE_STOPPING) {
     PostStopping();
   }
 }
 
-scoped_refptr<media::VideoFrame> VideoCaptureController::ReserveOutputBuffer() {
-  base::AutoLock lock(buffer_pool_lock_);
-  if (!buffer_pool_.get())
-    return NULL;
-  return ReserveI420VideoFrame(buffer_pool_, gfx::Size(frame_info_.width,
-                                                       frame_info_.height));
+void VideoCaptureController::TryConfigureEncodedBitstream(
+    const media::RuntimeVideoEncodingParameters& params) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  video_capture_manager_->TryConfigureEncodedBitstream(
+      current_params_.session_id,
+      params);
 }
 
 // Implements VideoCaptureDevice::EventHandler.
 // OnIncomingCapturedFrame is called the thread running the capture device.
 // I.e.- DirectShow thread on windows and v4l2_thread on Linux.
 void VideoCaptureController::OnIncomingCapturedFrame(
     const uint8* data,
     int length,
     base::Time timestamp,
     int rotation,
@@ skipping 86 matching lines @@
                             libyuv::kRotate0, libyuv::FOURCC_MJPG);
       break;
     }
 #endif
     default:
       NOTREACHED();
   }
 
   BrowserThread::PostTask(BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&VideoCaptureController::DoIncomingCapturedFrameOnIOThread,
-                 this, dst, timestamp));
+      base::Bind(
+          &VideoCaptureController::DoIncomingCapturedVideoFrameOnIOThread,
+          this,
+          dst,
+          timestamp));
 }
 
 // OnIncomingCapturedVideoFrame is called the thread running the capture device.
 void VideoCaptureController::OnIncomingCapturedVideoFrame(
     const scoped_refptr<media::VideoFrame>& frame,
     base::Time timestamp) {
 
   scoped_refptr<media::VideoFrame> target;
   {
     base::AutoLock lock(buffer_pool_lock_);
 
     if (!buffer_pool_.get())
       return;
 
     // If this is a frame that belongs to the buffer pool, we can forward it
     // directly to the IO thread and be done.
     if (buffer_pool_->RecognizeReservedBuffer(
         frame->shared_memory_handle()) >= 0) {
       BrowserThread::PostTask(BrowserThread::IO,
           FROM_HERE,
-          base::Bind(&VideoCaptureController::DoIncomingCapturedFrameOnIOThread,
-                     this, frame, timestamp));
+          base::Bind(
+              &VideoCaptureController::DoIncomingCapturedVideoFrameOnIOThread,
+              this,
+              frame,
+              timestamp));
       return;
     }
     // Otherwise, this is a frame that belongs to the caller, and we must copy
     // it to a frame from the buffer pool.
     target = ReserveI420VideoFrame(buffer_pool_, gfx::Size(frame_info_.width,
                                                            frame_info_.height));
   }
 
   if (!target.get())
     return;
@@ skipping 74 matching lines @@
                                target->coded_size().height(),
                                frame->stride(kRGBPlane),
                                target->stride(kYPlane),
                                target->stride(kUPlane));
       break;
     }
   }
 
   BrowserThread::PostTask(BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&VideoCaptureController::DoIncomingCapturedFrameOnIOThread,
-                 this, target, timestamp));
+      base::Bind(
+          &VideoCaptureController::DoIncomingCapturedVideoFrameOnIOThread,
+          this,
+          target,
+          timestamp));
+}
+
+void VideoCaptureController::OnIncomingCapturedEncodedBitstreamBuffer(
+    const scoped_refptr<media::EncodedBitstreamBuffer>& buffer,
+    size_t data_size,
+    base::Time timestamp) {
+
+  scoped_refptr<media::EncodedBitstreamBuffer> target;
+  {
+    base::AutoLock lock(buffer_pool_lock_);
+    if (!buffer_pool_.get())
+      return;
+    // If this is a frame that belongs to the buffer pool, we can forward it
+    // directly to the IO thread and be done.
+    if (buffer_pool_->RecognizeReservedBuffer(
+        buffer->shared_memory_handle()) >= 0) {
+      BrowserThread::PostTask(BrowserThread::IO,
+          FROM_HERE,
+          base::Bind(
+              &VideoCaptureController::
+                  DoIncomingCapturedEncodedBitstreamBufferOnIOThread,
+              this,
+              buffer,
+              data_size,
+              timestamp));
+      return;
+    }
+    // Otherwise, this is a frame that belongs to the caller, and we must copy
+    // it to a frame from the buffer pool.
+    target = ReserveOutputEncodedBitstreamBuffer();
+  }
+
+  if (!target.get())
+    return;
+  if (data_size > target->size())
+    return;
+  memcpy(buffer_pool_->GetMemory(target->buffer_id()),
+         buffer->buffer(), data_size);
+  BrowserThread::PostTask(BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(
+          &VideoCaptureController::
+              DoIncomingCapturedEncodedBitstreamBufferOnIOThread,
+          this,
+          target,
+          data_size,
+          timestamp));
 }
 
 void VideoCaptureController::OnError() {
   BrowserThread::PostTask(BrowserThread::IO,
       FROM_HERE,
       base::Bind(&VideoCaptureController::DoErrorOnIOThread, this));
 }
 
 void VideoCaptureController::OnFrameInfo(
     const media::VideoCaptureCapability& info) {
   frame_info_= info;
   // Handle cases when |info| has odd numbers for width/height.
   if (info.width & 1) {
     --frame_info_.width;
     chopped_width_ = 1;
   } else {
     chopped_width_ = 0;
   }
   if (info.height & 1) {
     --frame_info_.height;
     chopped_height_ = 1;
   } else {
     chopped_height_ = 0;
   }
+
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&VideoCaptureController::DoFrameInfoOnIOThread, this, false));
+}
+
+void VideoCaptureController::OnEncodedFrameInfo(
+    const media::VideoEncodingParameters& encoded_info) {
+  encoded_frame_info_ = encoded_info;
+
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&VideoCaptureController::DoFrameInfoOnIOThread, this, true));
+}
+
+void VideoCaptureController::OnBitstreamConfigChanged(
+    const media::RuntimeVideoEncodingParameters& params) {
   BrowserThread::PostTask(BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&VideoCaptureController::DoFrameInfoOnIOThread, this));
+      base::Bind(&VideoCaptureController::DoBitstreamConfigChangedOnIOThread,
+                 this,
+                 params));
 }
 
-// static
-scoped_refptr<media::VideoFrame> VideoCaptureController::ReserveI420VideoFrame(
-    VideoCaptureBufferPool* buffer_pool, const gfx::Size& size) {
-  if ((size_t)(size.GetArea() * 3 / 2) > buffer_pool->GetMemorySize())
+scoped_refptr<media::VideoFrame>
+VideoCaptureController::ReserveOutputVideoFrame() {
+  base::AutoLock lock(buffer_pool_lock_);
+  if (!buffer_pool_.get())
     return NULL;
+  return ReserveI420VideoFrame(buffer_pool_, gfx::Size(frame_info_.width,
+                                                       frame_info_.height));
+}
 
-  int buffer_id = buffer_pool->ReserveForProducer();
-  if (buffer_id < 0)
+scoped_refptr<media::EncodedBitstreamBuffer>
+VideoCaptureController::ReserveOutputEncodedBitstreamBuffer() {
+  base::AutoLock lock(buffer_pool_lock_);
+  if (!buffer_pool_.get())
     return NULL;
-
-  base::Closure disposal_handler = base::Bind(
-      &VideoCaptureBufferPool::RelinquishProducerReservation,
-      buffer_pool,
-      buffer_id);
-
-  // Wrap the buffer in a VideoFrame container.
-  uint8* base_ptr = static_cast<uint8*>(buffer_pool->GetMemory(buffer_id));
-  size_t u_offset = size.GetArea();
-  size_t v_offset = u_offset + u_offset / 4;
-  scoped_refptr<media::VideoFrame> frame =
-      media::VideoFrame::WrapExternalYuvData(
-          buffer_pool->GetHandle(buffer_id),
-          media::VideoFrame::YV12,  // Actually it's I420, but equivalent here.
-          size, gfx::Rect(size), size,
-          size.width(),             // y stride
-          size.width() / 2,         // u stride
-          size.width() / 2,         // v stride
-          base_ptr,                 // y address
-          base_ptr + u_offset,      // u address
-          base_ptr + v_offset,      // v address
-          base::TimeDelta(),        // timestamp (unused).
-          disposal_handler);
-
-  return frame;
+  return ReserveEncodedBitstreamBuffer(buffer_pool_);
 }
 
 VideoCaptureController::~VideoCaptureController() {
   buffer_pool_ = NULL;  // Release all buffers.
   STLDeleteContainerPointers(controller_clients_.begin(),
                              controller_clients_.end());
   STLDeleteContainerPointers(pending_clients_.begin(),
                              pending_clients_.end());
 }
 
 // Called by VideoCaptureManager when a device have been stopped.
 void VideoCaptureController::OnDeviceStopped() {
   BrowserThread::PostTask(BrowserThread::IO,
       FROM_HERE,
       base::Bind(&VideoCaptureController::DoDeviceStoppedOnIOThread, this));
 }
 
-void VideoCaptureController::DoIncomingCapturedFrameOnIOThread(
-    const scoped_refptr<media::VideoFrame>& reserved_frame,
+void VideoCaptureController::DoIncomingCapturedVideoFrameOnIOThread(
+    const scoped_refptr<media::VideoFrame>& frame,
+    base::Time timestamp) {
+  DoIncomingCapturedSharedMemoryOnIOThread(
+      frame->shared_memory_handle(),
+      frame->coded_size().GetArea() * 3 / 2,
+      timestamp);
+}
+
+void VideoCaptureController::DoIncomingCapturedEncodedBitstreamBufferOnIOThread(
+    const scoped_refptr<media::EncodedBitstreamBuffer>& buffer,
+    size_t data_size,
+    base::Time timestamp) {
+  DoIncomingCapturedSharedMemoryOnIOThread(
+      buffer->shared_memory_handle(),
+      data_size,
+      timestamp);
+}
+
+void VideoCaptureController::DoIncomingCapturedSharedMemoryOnIOThread(
+    base::SharedMemoryHandle reserved_handle,
+    size_t data_size,
     base::Time timestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!buffer_pool_.get())
     return;
 
-  int buffer_id = buffer_pool_->RecognizeReservedBuffer(
-      reserved_frame->shared_memory_handle());
+  int buffer_id = buffer_pool_->RecognizeReservedBuffer(reserved_handle);
   if (buffer_id < 0) {
     NOTREACHED();
     return;
   }
 
   int count = 0;
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     for (ControllerClients::iterator client_it = controller_clients_.begin();
          client_it != controller_clients_.end(); ++client_it) {
       if ((*client_it)->session_closed)
         continue;
 
       (*client_it)->event_handler->OnBufferReady((*client_it)->controller_id,
-                                                 buffer_id, timestamp);
+                                                 buffer_id, data_size,
+                                                 timestamp, false);
       (*client_it)->buffers.insert(buffer_id);
       count++;
     }
   }
 
   buffer_pool_->HoldForConsumers(buffer_id, count);
 }
 
-void VideoCaptureController::DoFrameInfoOnIOThread() {
+void VideoCaptureController::DoFrameInfoOnIOThread(bool encoded) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!buffer_pool_.get())
       << "Device is restarted without releasing shared memory.";
 
   // Allocate memory only when device has been started.
   if (state_ != VIDEO_CAPTURE_STATE_STARTED)
     return;
 
-  scoped_refptr<VideoCaptureBufferPool> buffer_pool =
-      new VideoCaptureBufferPool(frame_info_.width * frame_info_.height * 3 / 2,
-                                 kNoOfBuffers);
+  scoped_refptr<VideoCaptureBufferPool> buffer_pool;
+  if (encoded) {
+    buffer_pool = new VideoCaptureBufferPool(
+        encoded_frame_info_.runtime_params.max_bitrate, kNoOfBuffers);
+  } else {
+    buffer_pool = new VideoCaptureBufferPool(
+        frame_info_.width * frame_info_.height * 3 / 2, kNoOfBuffers);
+  }
 
   // Check whether all buffers were created successfully.
   if (!buffer_pool->Allocate()) {
     state_ = VIDEO_CAPTURE_STATE_ERROR;
     for (ControllerClients::iterator client_it = controller_clients_.begin();
          client_it != controller_clients_.end(); ++client_it) {
       (*client_it)->event_handler->OnError((*client_it)->controller_id);
     }
     return;
   }
 
   {
     base::AutoLock lock(buffer_pool_lock_);
     buffer_pool_ = buffer_pool;
   }
-  frame_info_available_ = true;
+  if (encoded)
+    encoded_frame_info_available_ = true;
+  else
+    frame_info_available_ = true;
 
   for (ControllerClients::iterator client_it = controller_clients_.begin();
        client_it != controller_clients_.end(); ++client_it) {
     SendFrameInfoAndBuffers(*client_it);
   }
 }
 
+void VideoCaptureController::DoBitstreamConfigChangedOnIOThread(
+    const media::RuntimeVideoEncodingParameters& params) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  for (ControllerClients::iterator client_it = controller_clients_.begin();
+       client_it != controller_clients_.end(); ++client_it) {
+    (*client_it)->event_handler->OnBitstreamConfigChanged(
+        (*client_it)->controller_id,
+        params);
+  }
+}
+
 void VideoCaptureController::DoErrorOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   state_ = VIDEO_CAPTURE_STATE_ERROR;
   ControllerClients::iterator client_it;
   for (client_it = controller_clients_.begin();
        client_it != controller_clients_.end(); ++client_it) {
     (*client_it)->event_handler->OnError((*client_it)->controller_id);
   }
   for (client_it = pending_clients_.begin();
        client_it != pending_clients_.end(); ++client_it) {
     (*client_it)->event_handler->OnError((*client_it)->controller_id);
   }
 }
 
 void VideoCaptureController::DoDeviceStoppedOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   device_in_use_ = false;
   if (state_ == VIDEO_CAPTURE_STATE_STOPPING) {
     PostStopping();
   }
 }
 
 void VideoCaptureController::SendFrameInfoAndBuffers(ControllerClient* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(frame_info_available_);
-  client->event_handler->OnFrameInfo(client->controller_id,
-                                     frame_info_.width, frame_info_.height,
-                                     frame_info_.frame_rate);
-  if (!buffer_pool_.get())
-    return;
+  DCHECK(frame_info_available_ || encoded_frame_info_available_);
 
+  std::vector<base::SharedMemoryHandle> handles;
   for (int buffer_id = 0; buffer_id < buffer_pool_->count(); ++buffer_id) {
     base::SharedMemoryHandle remote_handle =
         buffer_pool_->ShareToProcess(buffer_id, client->render_process_handle);
-
-    client->event_handler->OnBufferCreated(client->controller_id,
-                                           remote_handle,
-                                           buffer_pool_->GetMemorySize(),
-                                           buffer_id);
+    handles.push_back(remote_handle);
+  }
+  if (frame_info_available_) {
+    DCHECK(!encoded_frame_info_available_);
+    media::VideoCaptureParams params;
+    params.width = frame_info_.width;
+    params.height = frame_info_.height;
+    params.frame_per_second = frame_info_.frame_rate;
+    params.session_id = client->parameters.session_id;
+    client->event_handler->OnFrameInfo(client->controller_id,
+                                       params,
+                                       handles,
+                                       buffer_pool_->GetMemorySize());
+  } else {
+    DCHECK(!frame_info_available_);
+    client->event_handler->OnEncodedFrameInfo(client->controller_id,
+                                              encoded_frame_info_,
+                                              handles,
+                                              buffer_pool_->GetMemorySize());
   }
 }
 
 VideoCaptureController::ControllerClient*
 VideoCaptureController::FindClient(
     const VideoCaptureControllerID& id,
     VideoCaptureControllerEventHandler* handler,
     const ControllerClients& clients) {
   for (ControllerClients::const_iterator client_it = clients.begin();
        client_it != clients.end(); ++client_it) {
@@ skipping 11 matching lines @@
     const ControllerClients& clients) {
   for (ControllerClients::const_iterator client_it = clients.begin();
        client_it != clients.end(); ++client_it) {
     if ((*client_it)->parameters.session_id == session_id) {
       return *client_it;
     }
   }
   return NULL;
 }
 
+// static
+scoped_refptr<media::VideoFrame> VideoCaptureController::ReserveI420VideoFrame(
+    VideoCaptureBufferPool* buffer_pool, const gfx::Size& size) {
+  if ((size_t)(size.GetArea() * 3 / 2) > buffer_pool->GetMemorySize())
+    return NULL;
+
+  int buffer_id = buffer_pool->ReserveForProducer();
+  if (buffer_id < 0)
+    return NULL;
+
+  base::Closure disposal_handler = base::Bind(
+      &VideoCaptureBufferPool::RelinquishProducerReservation,
+      buffer_pool,
+      buffer_id);
+
+  // Wrap the buffer in a VideoFrame container.
+  uint8* base_ptr = static_cast<uint8*>(buffer_pool->GetMemory(buffer_id));
+  size_t u_offset = size.GetArea();
+  size_t v_offset = u_offset + u_offset / 4;
+  scoped_refptr<media::VideoFrame> frame =
+      media::VideoFrame::WrapExternalYuvData(
+          buffer_pool->GetHandle(buffer_id),
+          media::VideoFrame::YV12,  // Actually it's I420, but equivalent here.
+          size, gfx::Rect(size), size,
+          size.width(),             // y stride
+          size.width() / 2,         // u stride
+          size.width() / 2,         // v stride
+          base_ptr,                 // y address
+          base_ptr + u_offset,      // u address
+          base_ptr + v_offset,      // v address
+          base::TimeDelta(),        // timestamp (unused).
+          disposal_handler);
+
+  return frame;
+}
+
+// static
+scoped_refptr<media::EncodedBitstreamBuffer>
+VideoCaptureController::ReserveEncodedBitstreamBuffer(
+    VideoCaptureBufferPool* buffer_pool) {
+  int buffer_id = buffer_pool->ReserveForProducer();
+  if (buffer_id < 0)
+    return NULL;
+
+  base::Closure disposal_handler = base::Bind(
+      &VideoCaptureBufferPool::RelinquishProducerReservation,
+      buffer_pool,
+      buffer_id);
+
+  // Wrap the buffer in a VideoFrame container.
+  media::BufferEncodingMetadata metadata;
+  metadata.key_frame = false;
+  scoped_refptr<media::EncodedBitstreamBuffer> frame =
+      new media::EncodedBitstreamBuffer(
+          buffer_id,
+          reinterpret_cast<uint8*>(buffer_pool->GetMemory(buffer_id)),
+          buffer_pool->GetMemorySize(),
+          buffer_pool->GetHandle(buffer_id),
+          metadata,
+          disposal_handler);
+  return frame;
+}
+
 // This function is called when all buffers have been returned to controller,
 // or when device is stopped. It decides whether the device needs to be
 // restarted.
 void VideoCaptureController::PostStopping() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(state_, VIDEO_CAPTURE_STATE_STOPPING);
 
   // When clients still have some buffers, or device has not been stopped yet,
   // do nothing.
   if ((buffer_pool_.get() && buffer_pool_->IsAnyBufferHeldForConsumers()) ||
@@ skipping 31 matching lines @@
     controller_clients_.push_back((*client_it));
     pending_clients_.erase(client_it++);
   }
   // Request the manager to start the actual capture.
   video_capture_manager_->Start(current_params_, this);
   state_ = VIDEO_CAPTURE_STATE_STARTED;
   device_in_use_ = true;
 }
 
 }  // namespace content