getUserMedia: handle the device starting status report.

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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 129 matching lines @@
   }
 }
 
 mojo::ScopedSharedBufferHandle
 VideoCaptureController::BufferContext::CloneHandle() {
   return buffer_handle_->Clone();
 }
 
 VideoCaptureController::VideoCaptureController()
     : consumer_feedback_observer_(nullptr),
-      state_(VIDEO_CAPTURE_STATE_STARTED),
+      state_(VIDEO_CAPTURE_STATE_STARTING),
       has_received_frames_(false),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 VideoCaptureController::~VideoCaptureController() = default;
 
 base::WeakPtr<VideoCaptureController>
 VideoCaptureController::GetWeakPtrForIOThread() {
   return weak_ptr_factory_.GetWeakPtr();
@@ skipping 40 matching lines @@
   // Signal error in case device is already in error state.
   if (state_ == VIDEO_CAPTURE_STATE_ERROR) {
     event_handler->OnError(id);
     return;
   }
 
   // Do nothing if this client has called AddClient before.
   if (FindClient(id, event_handler, controller_clients_))
     return;
 
+  // If the device has reported OnStarted event, report it to this client here.
+  if (state_ == VIDEO_CAPTURE_STATE_STARTED)
+    event_handler->OnStarted(id);
+
   std::unique_ptr<ControllerClient> client =
       base::MakeUnique<ControllerClient>(id, event_handler, session_id, params);
   // If we already have gotten frame_info from the device, repeat it to the new
   // client.
-  if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
+  if (state_ != VIDEO_CAPTURE_STATE_ERROR) {
     controller_clients_.push_back(std::move(client));
-    return;
   }
 }
 
 int VideoCaptureController::RemoveClient(
     VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* event_handler) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureController::RemoveClient, id " << id;
 
   ControllerClient* client = FindClient(id, event_handler, controller_clients_);
@@ skipping 139 matching lines @@
         buffer_read_permission,
     media::mojom::VideoFrameInfoPtr frame_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_NE(buffer_id, media::VideoCaptureBufferPool::kInvalidId);
 
   auto buffer_context_iter = FindUnretiredBufferContextFromBufferId(buffer_id);
   DCHECK(buffer_context_iter != buffer_contexts_.end());
   buffer_context_iter->set_frame_feedback_id(frame_feedback_id);
   DCHECK(!buffer_context_iter->HasConsumers());
 
-  if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
+  if (state_ != VIDEO_CAPTURE_STATE_ERROR) {
     const int buffer_context_id = buffer_context_iter->buffer_context_id();
     for (const auto& client : controller_clients_) {
       if (client->session_closed || client->paused)
         continue;
 
       // On the first use of a BufferContext for a particular client, call
       // OnBufferCreated().
       if (!base::ContainsValue(client->known_buffer_context_ids,
                                buffer_context_id)) {
         client->known_buffer_context_ids.push_back(buffer_context_id);
@@ skipping 68 matching lines @@
   }
 }
 
 void VideoCaptureController::OnLog(const std::string& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   MediaStreamManager::SendMessageToNativeLog("Video capture: " + message);
 }
 
 void VideoCaptureController::OnStarted() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  state_ = VIDEO_CAPTURE_STATE_STARTED;
 
   for (const auto& client : controller_clients_) {
     if (client->session_closed)
       continue;
     client->event_handler->OnStarted(client->controller_id);
   }
 }
 
 VideoCaptureController::ControllerClient* VideoCaptureController::FindClient(
     VideoCaptureControllerID id,
@@ skipping 61 matching lines @@
     if (entry_iter != std::end(client->known_buffer_context_ids)) {
       client->known_buffer_context_ids.erase(entry_iter);
       client->event_handler->OnBufferDestroyed(
           client->controller_id, buffer_context_iter->buffer_context_id());
     }
   }
   buffer_contexts_.erase(buffer_context_iter);
 }
 
 }  // namespace content