Move content\browser\renderer_host\media to content namespace.

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/yuv_convert.h"
 
-using content::BrowserThread;
+namespace content {
 
 // The number of DIBs VideoCaptureController allocate.
 static const size_t kNoOfDIBS = 3;
 
 struct VideoCaptureController::ControllerClient {
   ControllerClient(
       const VideoCaptureControllerID& id,
       VideoCaptureControllerEventHandler* handler,
       base::ProcessHandle render_process,
       const media::VideoCaptureParams& params)
@@ skipping 31 matching lines @@
 
   // The memory created to be shared with renderer processes.
   scoped_ptr<base::SharedMemory> shared_memory;
 
   // Number of renderer processes which hold this shared memory.
   // renderer process is represented by VidoeCaptureHost.
   int references;
 };
 
 VideoCaptureController::VideoCaptureController(
-    media_stream::VideoCaptureManager* video_capture_manager)
+    VideoCaptureManager* video_capture_manager)
     : chopped_width_(0),
       chopped_height_(0),
       frame_info_available_(false),
       video_capture_manager_(video_capture_manager),
       device_in_use_(false),
-      state_(video_capture::kStopped) {
+      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,
     const media::VideoCaptureParams& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "VideoCaptureController::StartCapture, id " << id.device_id
            << ", (" << params.width
            << ", " << params.height
            << ", " << params.frame_per_second
            << ", " << params.session_id
            << ")";
 
   // Signal error in case device is already in error state.
-  if (state_ == video_capture::kError) {
+  if (state_ == VIDEO_CAPTURE_STATE_ERROR) {
     event_handler->OnError(id);
     return;
   }
 
   // Do nothing if this client has called StartCapture before.
   if (FindClient(id, event_handler, controller_clients_) ||
       FindClient(id, event_handler, pending_clients_))
     return;
 
   ControllerClient* client = new ControllerClient(id, event_handler,
                                                   render_process, params);
   // In case capture has been started, need to check different condtions.
-  if (state_ == video_capture::kStarted) {
+  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;
-      state_ = video_capture::kStopping;
+      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_) {
       int buffer_size = (frame_info_.width * frame_info_.height * 3) / 2;
       SendFrameInfoAndBuffers(client, buffer_size);
     }
     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::kStopping) {
+  if (state_ == VIDEO_CAPTURE_STATE_STOPPING) {
     pending_clients_.push_back(client);
     return;
   }
 
   // Fresh start.
   controller_clients_.push_back(client);
   current_params_ = params;
   // Order the manager to start the actual capture.
   video_capture_manager_->Start(params, this);
-  state_ = video_capture::kStarted;
+  state_ = VIDEO_CAPTURE_STATE_STARTED;
   device_in_use_ = true;
 }
 
 void VideoCaptureController::StopCapture(
     const VideoCaptureControllerID& id,
     VideoCaptureControllerEventHandler* event_handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "VideoCaptureController::StopCapture, id " << id.device_id;
 
   ControllerClient* client = FindClient(id, event_handler, pending_clients_);
@@ skipping 22 matching lines @@
       dib_it->second->references -= 1;
     }
   }
   client->buffers.clear();
 
   int session_id = client->parameters.session_id;
   delete client;
   controller_clients_.remove(client);
 
   // No more clients. Stop device.
-  if (controller_clients_.empty() && state_ == video_capture::kStarted) {
+  if (controller_clients_.empty() && state_ == VIDEO_CAPTURE_STATE_STARTED) {
     video_capture_manager_->Stop(session_id,
         base::Bind(&VideoCaptureController::OnDeviceStopped, this));
     frame_info_available_ = false;
-    state_ = video_capture::kStopping;
+    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_);
   if (!client)
@@ skipping 27 matching lines @@
     DCHECK_GT(dib_it->second->references, 0)
         << "The buffer is not used by renderer.";
     dib_it->second->references -= 1;
     if (dib_it->second->references > 0)
       return;
   }
 
   // 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 (!ClientHasDIB() && state_ == video_capture::kStopping) {
+  if (!ClientHasDIB() && state_ == VIDEO_CAPTURE_STATE_STOPPING) {
     PostStopping();
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // 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,
@@ skipping 133 matching lines @@
   BrowserThread::PostTask(BrowserThread::IO,
       FROM_HERE,
       base::Bind(&VideoCaptureController::DoDeviceStoppedOnIOThread, this));
 }
 
 void VideoCaptureController::DoIncomingCapturedFrameOnIOThread(
     int buffer_id, base::Time timestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   int count = 0;
-  if (state_ == video_capture::kStarted) {
+  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);
       (*client_it)->buffers.insert(buffer_id);
       count++;
     }
   }
 
   base::AutoLock lock(lock_);
   if (owned_dibs_.find(buffer_id) != owned_dibs_.end()) {
     DCHECK_EQ(owned_dibs_[buffer_id]->references, -1);
     owned_dibs_[buffer_id]->references = count;
   }
 }
 
 void VideoCaptureController::DoFrameInfoOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(owned_dibs_.empty())
       << "Device is restarted without releasing shared memory.";
 
   // Allocate memory only when device has been started.
-  if (state_ != video_capture::kStarted)
+  if (state_ != VIDEO_CAPTURE_STATE_STARTED)
     return;
 
   bool frames_created = true;
   const size_t needed_size = (frame_info_.width * frame_info_.height * 3) / 2;
   {
     base::AutoLock lock(lock_);
     for (size_t i = 1; i <= kNoOfDIBS; ++i) {
       scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
       if (!shared_memory->CreateAndMapAnonymous(needed_size)) {
         frames_created = false;
         break;
       }
       SharedDIB* dib = new SharedDIB(shared_memory.release());
       owned_dibs_.insert(std::make_pair(i, dib));
     }
   }
   // Check whether all DIBs were created successfully.
   if (!frames_created) {
-    state_ = video_capture::kError;
+    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;
   }
   frame_info_available_ = true;
 
   for (ControllerClients::iterator client_it = controller_clients_.begin();
        client_it != controller_clients_.end(); client_it++) {
     SendFrameInfoAndBuffers((*client_it), static_cast<int>(needed_size));
   }
 }
 
 void VideoCaptureController::DoErrorOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  state_ = video_capture::kError;
+  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::kStopping) {
+  if (state_ == VIDEO_CAPTURE_STATE_STOPPING) {
     PostStopping();
   }
 }
 
 void VideoCaptureController::SendFrameInfoAndBuffers(
     ControllerClient* client, int buffer_size) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(frame_info_available_);
   client->event_handler->OnFrameInfo(client->controller_id,
                                      frame_info_.width, frame_info_.height,
@@ skipping 38 matching lines @@
     }
   }
   return NULL;
 }
 
 // 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::kStopping);
+  DCHECK_EQ(state_, VIDEO_CAPTURE_STATE_STOPPING);
 
   // When clients still have some buffers, or device has not been stopped yet,
   // do nothing.
   if (ClientHasDIB() || device_in_use_)
     return;
 
   {
     base::AutoLock lock(lock_);
     STLDeleteValues(&owned_dibs_);
   }
 
   // No more client. Therefore the controller is stopped.
   if (controller_clients_.empty() && pending_clients_.empty()) {
-    state_ = video_capture::kStopped;
+    state_ = VIDEO_CAPTURE_STATE_STOPPED;
     return;
   }
 
   // Restart the device.
   current_params_.width = 0;
   current_params_.height = 0;
   ControllerClients::iterator client_it;
   for (client_it = controller_clients_.begin();
        client_it != controller_clients_.end(); client_it++) {
     if (current_params_.width < (*client_it)->parameters.width)
       current_params_.width = (*client_it)->parameters.width;
     if (current_params_.height < (*client_it)->parameters.height)
       current_params_.height = (*client_it)->parameters.height;
   }
   for (client_it = pending_clients_.begin();
        client_it != pending_clients_.end(); ) {
     if (current_params_.width < (*client_it)->parameters.width)
       current_params_.width = (*client_it)->parameters.width;
     if (current_params_.height < (*client_it)->parameters.height)
       current_params_.height = (*client_it)->parameters.height;
     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::kStarted;
+  state_ = VIDEO_CAPTURE_STATE_STARTED;
   device_in_use_ = true;
 }
 
 bool VideoCaptureController::ClientHasDIB() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   base::AutoLock lock(lock_);
   for (DIBMap::iterator dib_it = owned_dibs_.begin();
        dib_it != owned_dibs_.end(); dib_it++) {
     if (dib_it->second->references > 0)
       return true;
   }
   return false;
 }
+
+}  // namespace content