Shift media_stream::StreamOptions to align with the new getUserMedia spec

content/browser/renderer_host/media/media_stream_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/browser/renderer_host/media/media_stream_manager.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 27 matching lines @@
     int random_char = base::RandGenerator(sizeof(alphabet) - 1);
     label[i] = alphabet[random_char];
   }
   return label;
 }
 
 // Helper to verify if a media stream type is part of options or not.
 static bool Requested(const StreamOptions& options,
                       MediaStreamType stream_type) {
   if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE &&
-      (options.video_option != StreamOptions::kNoCamera)) {
+      options.video) {
     return true;
   } else if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE &&
-             options.audio == true) {
+             options.audio) {
     return true;
   }
   return false;
 }
 
 struct MediaStreamManager::DeviceRequest {
   enum RequestState {
     kNotRequested = 0,
     kRequested,
     kPendingApproval,
     kOpening,
     kDone,
     kError
   };
 
   enum RequestType {
     kGenerateStream = 0,
     kEnumerateDevices,
     kOpenDevice
   };
 
   DeviceRequest()
       : requester(NULL),
         state(content::NUM_MEDIA_STREAM_DEVICE_TYPES, kNotRequested),
         type(kGenerateStream) {
     options.audio = false;
-    options.video_option = StreamOptions::kNoCamera;
+    options.video = false;
   }
 
   DeviceRequest(MediaStreamRequester* requester,
                 const StreamOptions& request_options)
       : requester(requester),
         options(request_options),
         state(content::NUM_MEDIA_STREAM_DEVICE_TYPES, kNotRequested),
         type(kGenerateStream) {
     DCHECK(requester);
   }
@@ skipping 132 matching lines @@
     MediaStreamType type,
     const std::string& security_origin,
     std::string* label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Create a new request.
   StreamOptions options;
   if (type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE)
     options.audio = true;
   else
-    options.video_option = StreamOptions::kFacingUser;
+    options.video = true;
 
   DeviceRequest new_request = DeviceRequest(requester, options);
   new_request.type = DeviceRequest::kEnumerateDevices;
 
   StartEnumeration(&new_request, render_process_id, render_view_id,
                    security_origin, label);
 }
 
 void MediaStreamManager::OpenDevice(
     MediaStreamRequester* requester,
     int render_process_id,
     int render_view_id,
     const std::string& device_id,
     MediaStreamType type,
     const std::string& security_origin,
     std::string* label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Create a new request.
   StreamOptions options;
   if (type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE)
     options.audio = true;
   else
-    options.video_option = StreamOptions::kFacingUser;
+    options.video = true;
 
   DeviceRequest new_request = DeviceRequest(requester, options);
   new_request.type = DeviceRequest::kOpenDevice;
   new_request.requested_device_id = device_id;
 
   StartEnumeration(&new_request, render_process_id, render_view_id,
                    security_origin, label);
 }
 
 void MediaStreamManager::StartEnumeration(
@@ skipping 322 matching lines @@
   if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE) {
     return video_capture_manager();
   } else if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE) {
     return audio_input_device_manager();
   }
   NOTREACHED();
   return NULL;
 }
 
 }  // namespace media_stream