Home | History | Annotate | Download | only in media 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/renderer/media/media_stream_video_source.h"
      6 
      7 #include <algorithm>
      8 #include <limits>
      9 #include <string>
     10 
     11 #include "base/debug/trace_event.h"
     12 #include "base/logging.h"
     13 #include "base/strings/string_number_conversions.h"
     14 #include "content/child/child_process.h"
     15 #include "content/renderer/media/media_stream_constraints_util.h"
     16 #include "content/renderer/media/media_stream_video_track.h"
     17 #include "content/renderer/media/video_track_adapter.h"
     18 
     19 namespace content {
     20 
     21 // Constraint keys. Specified by draft-alvestrand-constraints-resolution-00b
     22 const char MediaStreamVideoSource::kMinAspectRatio[] = "minAspectRatio";
     23 const char MediaStreamVideoSource::kMaxAspectRatio[] = "maxAspectRatio";
     24 const char MediaStreamVideoSource::kMaxWidth[] = "maxWidth";
     25 const char MediaStreamVideoSource::kMinWidth[] = "minWidth";
     26 const char MediaStreamVideoSource::kMaxHeight[] = "maxHeight";
     27 const char MediaStreamVideoSource::kMinHeight[] = "minHeight";
     28 const char MediaStreamVideoSource::kMaxFrameRate[] = "maxFrameRate";
     29 const char MediaStreamVideoSource::kMinFrameRate[] = "minFrameRate";
     30 
     31 const char* kSupportedConstraints[] = {
     32   MediaStreamVideoSource::kMaxAspectRatio,
     33   MediaStreamVideoSource::kMinAspectRatio,
     34   MediaStreamVideoSource::kMaxWidth,
     35   MediaStreamVideoSource::kMinWidth,
     36   MediaStreamVideoSource::kMaxHeight,
     37   MediaStreamVideoSource::kMinHeight,
     38   MediaStreamVideoSource::kMaxFrameRate,
     39   MediaStreamVideoSource::kMinFrameRate,
     40 };
     41 
     42 const int MediaStreamVideoSource::kDefaultWidth = 640;
     43 const int MediaStreamVideoSource::kDefaultHeight = 480;
     44 const int MediaStreamVideoSource::kDefaultFrameRate = 30;
     45 const int MediaStreamVideoSource::kUnknownFrameRate = 0;
     46 
     47 namespace {
     48 
     49 // Google-specific key prefix. Constraints with this prefix are ignored if they
     50 // are unknown.
     51 const char kGooglePrefix[] = "goog";
     52 
     53 // Returns true if |constraint| has mandatory constraints.
     54 bool HasMandatoryConstraints(const blink::WebMediaConstraints& constraints) {
     55   blink::WebVector<blink::WebMediaConstraint> mandatory_constraints;
     56   constraints.getMandatoryConstraints(mandatory_constraints);
     57   return !mandatory_constraints.isEmpty();
     58 }
     59 
     60 // Retrieve the desired max width and height from |constraints|. If not set,
     61 // the |desired_width| and |desired_height| are set to
     62 // std::numeric_limits<int>::max();
     63 // If either max width or height is set as a mandatory constraint, the optional
     64 // constraints are not checked.
     65 void GetDesiredMaxWidthAndHeight(const blink::WebMediaConstraints& constraints,
     66                                  int* desired_width, int* desired_height) {
     67   *desired_width = std::numeric_limits<int>::max();
     68   *desired_height = std::numeric_limits<int>::max();
     69 
     70   bool mandatory = GetMandatoryConstraintValueAsInteger(
     71       constraints,
     72       MediaStreamVideoSource::kMaxWidth,
     73       desired_width);
     74   mandatory |= GetMandatoryConstraintValueAsInteger(
     75       constraints,
     76       MediaStreamVideoSource::kMaxHeight,
     77       desired_height);
     78   if (mandatory)
     79     return;
     80 
     81   GetOptionalConstraintValueAsInteger(constraints,
     82                                       MediaStreamVideoSource::kMaxWidth,
     83                                       desired_width);
     84   GetOptionalConstraintValueAsInteger(constraints,
     85                                       MediaStreamVideoSource::kMaxHeight,
     86                                       desired_height);
     87 }
     88 
     89 // Retrieve the desired max and min aspect ratio from |constraints|. If not set,
     90 // the |min_aspect_ratio| is set to 0 and |max_aspect_ratio| is set to
     91 // std::numeric_limits<double>::max();
     92 // If either min or max aspect ratio is set as a mandatory constraint, the
     93 // optional constraints are not checked.
     94 void GetDesiredMinAndMaxAspectRatio(
     95     const blink::WebMediaConstraints& constraints,
     96     double* min_aspect_ratio,
     97     double* max_aspect_ratio) {
     98   *min_aspect_ratio = 0;
     99   *max_aspect_ratio = std::numeric_limits<double>::max();
    100 
    101   bool mandatory = GetMandatoryConstraintValueAsDouble(
    102       constraints,
    103       MediaStreamVideoSource::kMinAspectRatio,
    104       min_aspect_ratio);
    105   mandatory |= GetMandatoryConstraintValueAsDouble(
    106       constraints,
    107       MediaStreamVideoSource::kMaxAspectRatio,
    108       max_aspect_ratio);
    109   if (mandatory)
    110     return;
    111 
    112   GetOptionalConstraintValueAsDouble(
    113       constraints,
    114       MediaStreamVideoSource::kMinAspectRatio,
    115       min_aspect_ratio);
    116   GetOptionalConstraintValueAsDouble(
    117       constraints,
    118       MediaStreamVideoSource::kMaxAspectRatio,
    119       max_aspect_ratio);
    120 }
    121 
    122 // Returns true if |constraint| is fulfilled. |format| can be changed by a
    123 // constraint, e.g. the frame rate can be changed by setting maxFrameRate.
    124 bool UpdateFormatForConstraint(
    125     const blink::WebMediaConstraint& constraint,
    126     bool mandatory,
    127     media::VideoCaptureFormat* format) {
    128   DCHECK(format != NULL);
    129 
    130   if (!format->IsValid())
    131     return false;
    132 
    133   std::string constraint_name = constraint.m_name.utf8();
    134   std::string constraint_value = constraint.m_value.utf8();
    135 
    136   if (constraint_name.find(kGooglePrefix) == 0) {
    137     // These are actually options, not constraints, so they can be satisfied
    138     // regardless of the format.
    139     return true;
    140   }
    141 
    142   if (constraint_name == MediaStreamSource::kSourceId) {
    143     // This is a constraint that doesn't affect the format.
    144     return true;
    145   }
    146 
    147   // Ignore Chrome specific Tab capture constraints.
    148   if (constraint_name == kMediaStreamSource ||
    149       constraint_name == kMediaStreamSourceId)
    150     return true;
    151 
    152   if (constraint_name == MediaStreamVideoSource::kMinAspectRatio ||
    153       constraint_name == MediaStreamVideoSource::kMaxAspectRatio) {
    154     // These constraints are handled by cropping if the camera outputs the wrong
    155     // aspect ratio.
    156     double value;
    157     return base::StringToDouble(constraint_value, &value);
    158   }
    159 
    160   double value = 0.0;
    161   if (!base::StringToDouble(constraint_value, &value)) {
    162     DLOG(WARNING) << "Can't parse MediaStream constraint. Name:"
    163                   <<  constraint_name << " Value:" << constraint_value;
    164     return false;
    165   }
    166 
    167   if (constraint_name == MediaStreamVideoSource::kMinWidth) {
    168     return (value <= format->frame_size.width());
    169   } else if (constraint_name == MediaStreamVideoSource::kMaxWidth) {
    170     return value > 0.0;
    171   } else if (constraint_name == MediaStreamVideoSource::kMinHeight) {
    172     return (value <= format->frame_size.height());
    173   } else if (constraint_name == MediaStreamVideoSource::kMaxHeight) {
    174      return value > 0.0;
    175   } else if (constraint_name == MediaStreamVideoSource::kMinFrameRate) {
    176     return (value > 0.0) && (value <= format->frame_rate);
    177   } else if (constraint_name == MediaStreamVideoSource::kMaxFrameRate) {
    178     if (value <= 0.0) {
    179       // The frame rate is set by constraint.
    180       // Don't allow 0 as frame rate if it is a mandatory constraint.
    181       // Set the frame rate to 1 if it is not mandatory.
    182       if (mandatory) {
    183         return false;
    184       } else {
    185         value = 1.0;
    186       }
    187     }
    188     format->frame_rate =
    189         (format->frame_rate > value) ? value : format->frame_rate;
    190     return true;
    191   } else {
    192     LOG(WARNING) << "Found unknown MediaStream constraint. Name:"
    193                  <<  constraint_name << " Value:" << constraint_value;
    194     return false;
    195   }
    196 }
    197 
    198 // Removes media::VideoCaptureFormats from |formats| that don't meet
    199 // |constraint|.
    200 void FilterFormatsByConstraint(
    201     const blink::WebMediaConstraint& constraint,
    202     bool mandatory,
    203     media::VideoCaptureFormats* formats) {
    204   DVLOG(3) << "FilterFormatsByConstraint("
    205            << "{ constraint.m_name = " << constraint.m_name.utf8()
    206            << "  constraint.m_value = " << constraint.m_value.utf8()
    207            << "  mandatory =  " << mandatory << "})";
    208   media::VideoCaptureFormats::iterator format_it = formats->begin();
    209   while (format_it != formats->end()) {
    210     // Modify the format_it to fulfill the constraint if possible.
    211     // Delete it otherwise.
    212     if (!UpdateFormatForConstraint(constraint, mandatory, &(*format_it))) {
    213       format_it = formats->erase(format_it);
    214     } else {
    215       ++format_it;
    216     }
    217   }
    218 }
    219 
    220 // Returns the media::VideoCaptureFormats that matches |constraints|.
    221 media::VideoCaptureFormats FilterFormats(
    222     const blink::WebMediaConstraints& constraints,
    223     const media::VideoCaptureFormats& supported_formats,
    224     blink::WebString* unsatisfied_constraint) {
    225   if (constraints.isNull()) {
    226     return supported_formats;
    227   }
    228 
    229   double max_aspect_ratio;
    230   double min_aspect_ratio;
    231   GetDesiredMinAndMaxAspectRatio(constraints,
    232                                  &min_aspect_ratio,
    233                                  &max_aspect_ratio);
    234 
    235   if (min_aspect_ratio > max_aspect_ratio || max_aspect_ratio < 0.05f) {
    236     DLOG(WARNING) << "Wrong requested aspect ratio.";
    237     return media::VideoCaptureFormats();
    238   }
    239 
    240   int min_width = 0;
    241   GetMandatoryConstraintValueAsInteger(constraints,
    242                                        MediaStreamVideoSource::kMinWidth,
    243                                        &min_width);
    244   int min_height = 0;
    245   GetMandatoryConstraintValueAsInteger(constraints,
    246                                        MediaStreamVideoSource::kMinHeight,
    247                                        &min_height);
    248   int max_width;
    249   int max_height;
    250   GetDesiredMaxWidthAndHeight(constraints, &max_width, &max_height);
    251 
    252   if (min_width > max_width || min_height > max_height)
    253     return media::VideoCaptureFormats();
    254 
    255   double min_frame_rate = 0.0f;
    256   double max_frame_rate = 0.0f;
    257   if (GetConstraintValueAsDouble(constraints,
    258                                  MediaStreamVideoSource::kMaxFrameRate,
    259                                  &max_frame_rate) &&
    260       GetConstraintValueAsDouble(constraints,
    261                                  MediaStreamVideoSource::kMinFrameRate,
    262                                  &min_frame_rate)) {
    263     if (min_frame_rate > max_frame_rate) {
    264       DLOG(WARNING) << "Wrong requested frame rate.";
    265       return media::VideoCaptureFormats();
    266     }
    267   }
    268 
    269   blink::WebVector<blink::WebMediaConstraint> mandatory;
    270   blink::WebVector<blink::WebMediaConstraint> optional;
    271   constraints.getMandatoryConstraints(mandatory);
    272   constraints.getOptionalConstraints(optional);
    273   media::VideoCaptureFormats candidates = supported_formats;
    274   for (size_t i = 0; i < mandatory.size(); ++i) {
    275     FilterFormatsByConstraint(mandatory[i], true, &candidates);
    276     if (candidates.empty()) {
    277       *unsatisfied_constraint = mandatory[i].m_name;
    278       return candidates;
    279     }
    280   }
    281 
    282   if (candidates.empty())
    283     return candidates;
    284 
    285   // Ok - all mandatory checked and we still have candidates.
    286   // Let's try filtering using the optional constraints. The optional
    287   // constraints must be filtered in the order they occur in |optional|.
    288   // But if a constraint produce zero candidates, the constraint is ignored and
    289   // the next constraint is tested.
    290   // http://dev.w3.org/2011/webrtc/editor/getusermedia.html#idl-def-Constraints
    291   for (size_t i = 0; i < optional.size(); ++i) {
    292     media::VideoCaptureFormats current_candidates = candidates;
    293     FilterFormatsByConstraint(optional[i], false, &current_candidates);
    294     if (!current_candidates.empty()) {
    295       candidates = current_candidates;
    296     }
    297   }
    298 
    299   // We have done as good as we can to filter the supported resolutions.
    300   return candidates;
    301 }
    302 
    303 const media::VideoCaptureFormat& GetBestFormatBasedOnArea(
    304     const media::VideoCaptureFormats& formats,
    305     int area) {
    306   media::VideoCaptureFormats::const_iterator it = formats.begin();
    307   media::VideoCaptureFormats::const_iterator best_it = formats.begin();
    308   int best_diff = std::numeric_limits<int>::max();
    309   for (; it != formats.end(); ++it) {
    310     int diff = abs(area - it->frame_size.width() * it->frame_size.height());
    311     if (diff < best_diff) {
    312       best_diff = diff;
    313       best_it = it;
    314     }
    315   }
    316   return *best_it;
    317 }
    318 
    319 // Find the format that best matches the default video size.
    320 // This algorithm is chosen since a resolution must be picked even if no
    321 // constraints are provided. We don't just select the maximum supported
    322 // resolution since higher resolutions cost more in terms of complexity and
    323 // many cameras have lower frame rate and have more noise in the image at
    324 // their maximum supported resolution.
    325 void GetBestCaptureFormat(
    326     const media::VideoCaptureFormats& formats,
    327     const blink::WebMediaConstraints& constraints,
    328     media::VideoCaptureFormat* capture_format) {
    329   DCHECK(!formats.empty());
    330 
    331   int max_width;
    332   int max_height;
    333   GetDesiredMaxWidthAndHeight(constraints, &max_width, &max_height);
    334 
    335   *capture_format = GetBestFormatBasedOnArea(
    336       formats,
    337       std::min(max_width, MediaStreamVideoSource::kDefaultWidth) *
    338       std::min(max_height, MediaStreamVideoSource::kDefaultHeight));
    339 }
    340 
    341 }  // anonymous namespace
    342 
    343 // static
    344 MediaStreamVideoSource* MediaStreamVideoSource::GetVideoSource(
    345     const blink::WebMediaStreamSource& source) {
    346   return static_cast<MediaStreamVideoSource*>(source.extraData());
    347 }
    348 
    349 // static
    350 bool MediaStreamVideoSource::IsConstraintSupported(const std::string& name) {
    351   for (size_t i = 0; i < arraysize(kSupportedConstraints); ++i) {
    352     if (kSupportedConstraints[i] == name)
    353       return true;
    354   }
    355   return false;
    356 }
    357 
    358 MediaStreamVideoSource::MediaStreamVideoSource()
    359     : state_(NEW),
    360       track_adapter_(new VideoTrackAdapter(
    361           ChildProcess::current()->io_message_loop_proxy())),
    362       weak_factory_(this) {
    363 }
    364 
    365 MediaStreamVideoSource::~MediaStreamVideoSource() {
    366   DCHECK(CalledOnValidThread());
    367 }
    368 
    369 void MediaStreamVideoSource::AddTrack(
    370     MediaStreamVideoTrack* track,
    371     const VideoCaptureDeliverFrameCB& frame_callback,
    372     const blink::WebMediaConstraints& constraints,
    373     const ConstraintsCallback& callback) {
    374   DCHECK(CalledOnValidThread());
    375   DCHECK(!constraints.isNull());
    376   DCHECK(std::find(tracks_.begin(), tracks_.end(),
    377                    track) == tracks_.end());
    378   tracks_.push_back(track);
    379 
    380   requested_constraints_.push_back(
    381       RequestedConstraints(track, frame_callback, constraints, callback));
    382 
    383   switch (state_) {
    384     case NEW: {
    385       // Tab capture and Screen capture needs the maximum requested height
    386       // and width to decide on the resolution.
    387       int max_requested_width = 0;
    388       GetMandatoryConstraintValueAsInteger(constraints, kMaxWidth,
    389                                            &max_requested_width);
    390 
    391       int max_requested_height = 0;
    392       GetMandatoryConstraintValueAsInteger(constraints, kMaxHeight,
    393                                            &max_requested_height);
    394 
    395       double max_requested_frame_rate;
    396       if (!GetConstraintValueAsDouble(constraints, kMaxFrameRate,
    397                                       &max_requested_frame_rate)) {
    398         max_requested_frame_rate = kDefaultFrameRate;
    399       }
    400 
    401       state_ = RETRIEVING_CAPABILITIES;
    402       GetCurrentSupportedFormats(
    403           max_requested_width,
    404           max_requested_height,
    405           max_requested_frame_rate,
    406           base::Bind(&MediaStreamVideoSource::OnSupportedFormats,
    407                      weak_factory_.GetWeakPtr()));
    408 
    409       break;
    410     }
    411     case STARTING:
    412     case RETRIEVING_CAPABILITIES: {
    413       // The |callback| will be triggered once the source has started or
    414       // the capabilities have been retrieved.
    415       break;
    416     }
    417     case ENDED:
    418     case STARTED: {
    419       // Currently, reconfiguring the source is not supported.
    420       FinalizeAddTrack();
    421     }
    422   }
    423 }
    424 
    425 void MediaStreamVideoSource::RemoveTrack(MediaStreamVideoTrack* video_track) {
    426   DCHECK(CalledOnValidThread());
    427   std::vector<MediaStreamVideoTrack*>::iterator it =
    428       std::find(tracks_.begin(), tracks_.end(), video_track);
    429   DCHECK(it != tracks_.end());
    430   tracks_.erase(it);
    431 
    432   // Check if |video_track| is waiting for applying new constraints and remove
    433   // the request in that case.
    434   for (std::vector<RequestedConstraints>::iterator it =
    435            requested_constraints_.begin();
    436        it != requested_constraints_.end(); ++it) {
    437     if (it->track == video_track) {
    438       requested_constraints_.erase(it);
    439       break;
    440     }
    441   }
    442   // Call |frame_adapter_->RemoveTrack| here even if adding the track has
    443   // failed and |frame_adapter_->AddCallback| has not been called.
    444   track_adapter_->RemoveTrack(video_track);
    445 
    446   if (tracks_.empty())
    447     StopSource();
    448 }
    449 
    450 const scoped_refptr<base::MessageLoopProxy>&
    451 MediaStreamVideoSource::io_message_loop() const {
    452   DCHECK(CalledOnValidThread());
    453   return track_adapter_->io_message_loop();
    454 }
    455 
    456 void MediaStreamVideoSource::DoStopSource() {
    457   DCHECK(CalledOnValidThread());
    458   DVLOG(3) << "DoStopSource()";
    459   if (state_ == ENDED)
    460     return;
    461   track_adapter_->StopFrameMonitoring();
    462   StopSourceImpl();
    463   state_ = ENDED;
    464   SetReadyState(blink::WebMediaStreamSource::ReadyStateEnded);
    465 }
    466 
    467 void MediaStreamVideoSource::OnSupportedFormats(
    468     const media::VideoCaptureFormats& formats) {
    469   DCHECK(CalledOnValidThread());
    470   DCHECK_EQ(RETRIEVING_CAPABILITIES, state_);
    471 
    472   supported_formats_ = formats;
    473   if (!FindBestFormatWithConstraints(supported_formats_,
    474                                      &current_format_)) {
    475     SetReadyState(blink::WebMediaStreamSource::ReadyStateEnded);
    476     // This object can be deleted after calling FinalizeAddTrack. See comment
    477     // in the header file.
    478     FinalizeAddTrack();
    479     return;
    480   }
    481 
    482   state_ = STARTING;
    483   DVLOG(3) << "Starting the capturer with " << current_format_.ToString();
    484 
    485   StartSourceImpl(
    486       current_format_,
    487       base::Bind(&VideoTrackAdapter::DeliverFrameOnIO, track_adapter_));
    488 }
    489 
    490 bool MediaStreamVideoSource::FindBestFormatWithConstraints(
    491     const media::VideoCaptureFormats& formats,
    492     media::VideoCaptureFormat* best_format) {
    493   DCHECK(CalledOnValidThread());
    494   // Find the first constraints that we can fulfill.
    495   for (std::vector<RequestedConstraints>::iterator request_it =
    496            requested_constraints_.begin();
    497        request_it != requested_constraints_.end(); ++request_it) {
    498     const blink::WebMediaConstraints& requested_constraints =
    499         request_it->constraints;
    500 
    501     // If the source doesn't support capability enumeration it is still ok if
    502     // no mandatory constraints have been specified. That just means that
    503     // we will start with whatever format is native to the source.
    504     if (formats.empty() && !HasMandatoryConstraints(requested_constraints)) {
    505       *best_format = media::VideoCaptureFormat();
    506       return true;
    507     }
    508     blink::WebString unsatisfied_constraint;
    509     media::VideoCaptureFormats filtered_formats =
    510         FilterFormats(requested_constraints, formats, &unsatisfied_constraint);
    511     if (filtered_formats.size() > 0) {
    512       // A request with constraints that can be fulfilled.
    513       GetBestCaptureFormat(filtered_formats,
    514                            requested_constraints,
    515                            best_format);
    516       return true;
    517     }
    518   }
    519   return false;
    520 }
    521 
    522 void MediaStreamVideoSource::OnStartDone(MediaStreamRequestResult result) {
    523   DCHECK(CalledOnValidThread());
    524   DVLOG(3) << "OnStartDone({result =" << result << "})";
    525   if (result == MEDIA_DEVICE_OK) {
    526     DCHECK_EQ(STARTING, state_);
    527     state_ = STARTED;
    528     SetReadyState(blink::WebMediaStreamSource::ReadyStateLive);
    529 
    530     track_adapter_->StartFrameMonitoring(
    531         current_format_.frame_rate,
    532         base::Bind(&MediaStreamVideoSource::SetMutedState,
    533                    weak_factory_.GetWeakPtr()));
    534 
    535   } else {
    536     StopSource();
    537   }
    538 
    539   // This object can be deleted after calling FinalizeAddTrack. See comment in
    540   // the header file.
    541   FinalizeAddTrack();
    542 }
    543 
    544 void MediaStreamVideoSource::FinalizeAddTrack() {
    545   DCHECK(CalledOnValidThread());
    546   media::VideoCaptureFormats formats;
    547   formats.push_back(current_format_);
    548 
    549   std::vector<RequestedConstraints> callbacks;
    550   callbacks.swap(requested_constraints_);
    551   for (std::vector<RequestedConstraints>::iterator it = callbacks.begin();
    552        it != callbacks.end(); ++it) {
    553     MediaStreamRequestResult result = MEDIA_DEVICE_OK;
    554     blink::WebString unsatisfied_constraint;
    555 
    556     if (HasMandatoryConstraints(it->constraints) &&
    557         FilterFormats(it->constraints, formats,
    558                       &unsatisfied_constraint).empty())
    559       result = MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED;
    560 
    561     if (state_ != STARTED && result == MEDIA_DEVICE_OK)
    562       result = MEDIA_DEVICE_TRACK_START_FAILURE;
    563 
    564     if (result == MEDIA_DEVICE_OK) {
    565       int max_width;
    566       int max_height;
    567       GetDesiredMaxWidthAndHeight(it->constraints, &max_width, &max_height);
    568       double max_aspect_ratio;
    569       double min_aspect_ratio;
    570       GetDesiredMinAndMaxAspectRatio(it->constraints,
    571                                      &min_aspect_ratio,
    572                                      &max_aspect_ratio);
    573       double max_frame_rate = 0.0f;
    574       GetConstraintValueAsDouble(it->constraints,
    575                                  kMaxFrameRate, &max_frame_rate);
    576 
    577       track_adapter_->AddTrack(it->track, it->frame_callback,
    578                                max_width, max_height,
    579                                min_aspect_ratio, max_aspect_ratio,
    580                                max_frame_rate);
    581     }
    582 
    583     DVLOG(3) << "FinalizeAddTrack() result " << result;
    584 
    585     if (!it->callback.is_null()) {
    586       it->callback.Run(this, result, unsatisfied_constraint);
    587     }
    588   }
    589 }
    590 
    591 void MediaStreamVideoSource::SetReadyState(
    592     blink::WebMediaStreamSource::ReadyState state) {
    593   DVLOG(3) << "MediaStreamVideoSource::SetReadyState state " << state;
    594   DCHECK(CalledOnValidThread());
    595   if (!owner().isNull())
    596     owner().setReadyState(state);
    597   for (std::vector<MediaStreamVideoTrack*>::iterator it = tracks_.begin();
    598        it != tracks_.end(); ++it) {
    599     (*it)->OnReadyStateChanged(state);
    600   }
    601 }
    602 
    603 void MediaStreamVideoSource::SetMutedState(bool muted_state) {
    604   DVLOG(3) << "MediaStreamVideoSource::SetMutedState state=" << muted_state;
    605   DCHECK(CalledOnValidThread());
    606   if (!owner().isNull()) {
    607     owner().setReadyState(muted_state
    608         ? blink::WebMediaStreamSource::ReadyStateMuted
    609         : blink::WebMediaStreamSource::ReadyStateLive);
    610   }
    611 }
    612 
    613 MediaStreamVideoSource::RequestedConstraints::RequestedConstraints(
    614     MediaStreamVideoTrack* track,
    615     const VideoCaptureDeliverFrameCB& frame_callback,
    616     const blink::WebMediaConstraints& constraints,
    617     const ConstraintsCallback& callback)
    618     : track(track),
    619       frame_callback(frame_callback),
    620       constraints(constraints),
    621       callback(callback) {
    622 }
    623 
    624 MediaStreamVideoSource::RequestedConstraints::~RequestedConstraints() {
    625 }
    626 
    627 }  // namespace content
    628