Changing constructor of BufferedDataSource to accept GURL and CORSMode

content/renderer/media/buffered_data_source.cc

 // Copyright 2013 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/renderer/media/buffered_data_source.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "content/public/common/url_constants.h"
@@ skipping 61 matching lines @@
   DCHECK(callback_.is_null());
 }
 
 // static
 void BufferedDataSource::ReadOperation::Run(
     scoped_ptr<ReadOperation> read_op, int result) {
   base::ResetAndReturn(&read_op->callback_).Run(result);
 }
 
 BufferedDataSource::BufferedDataSource(
+    const GURL& url,
+    BufferedResourceLoader::CORSMode cors_mode,
     const scoped_refptr<base::MessageLoopProxy>& render_loop,
     WebFrame* frame,
     media::MediaLog* media_log,
     BufferedDataSourceHost* host,
     const DownloadingCB& downloading_cb)
-    : cors_mode_(BufferedResourceLoader::kUnspecified),
+    : url_(url),
+      cors_mode_(cors_mode),
       total_bytes_(kPositionNotSpecified),
-      assume_fully_buffered_(false),
       streaming_(false),
       frame_(frame),
       intermediate_read_buffer_(new uint8[kInitialReadBufferSize]),
       intermediate_read_buffer_size_(kInitialReadBufferSize),
       render_loop_(render_loop),
       stop_signal_received_(false),
       media_has_played_(false),
       preload_(AUTO),
       bitrate_(0),
       playback_rate_(0.0),
@@ skipping 21 matching lines @@
   return new BufferedResourceLoader(url_,
                                     cors_mode_,
                                     first_byte_position,
                                     last_byte_position,
                                     strategy,
                                     bitrate_,
                                     playback_rate_,
                                     media_log_.get());
 }
 
-void BufferedDataSource::Initialize(
-    const GURL& url,
-    BufferedResourceLoader::CORSMode cors_mode,
-    const InitializeCB& init_cb) {
+void BufferedDataSource::Initialize(const InitializeCB& init_cb) {
   DCHECK(render_loop_->BelongsToCurrentThread());
   DCHECK(!init_cb.is_null());
   DCHECK(!loader_.get());
-  url_ = url;
-  cors_mode_ = cors_mode;
 
   init_cb_ = init_cb;
 
-  if (url_.SchemeIs(url::kHttpScheme) || url_.SchemeIs(url::kHttpsScheme)) {
+  if (url_.SchemeIsHTTPOrHTTPS()) {
     // Do an unbounded range request starting at the beginning.  If the server
     // responds with 200 instead of 206 we'll fall back into a streaming mode.
     loader_.reset(CreateResourceLoader(0, kPositionNotSpecified));
   } else {
     // For all other protocols, assume they support range request. We fetch
     // the full range of the resource to obtain the instance size because
     // we won't be served HTTP headers.
     loader_.reset(CreateResourceLoader(kPositionNotSpecified,
                                        kPositionNotSpecified));
-    assume_fully_buffered_ = true;
   }
 
   base::WeakPtr<BufferedDataSource> weak_this = weak_factory_.GetWeakPtr();
   loader_->Start(
       base::Bind(&BufferedDataSource::StartCallback, weak_this),
       base::Bind(&BufferedDataSource::LoadingStateChangedCallback, weak_this),
       base::Bind(&BufferedDataSource::ProgressCallback, weak_this),
       frame_);
 }
 
@@ skipping 182 matching lines @@
     init_cb_is_null = init_cb_.is_null();
   }
   if (init_cb_is_null) {
     loader_->Stop();
     return;
   }
 
   // All responses must be successful. Resources that are assumed to be fully
   // buffered must have a known content length.
   bool success = status == BufferedResourceLoader::kOk &&
-      (!assume_fully_buffered_ ||
-       loader_->instance_size() != kPositionNotSpecified);
+                 (!assume_fully_buffered() ||
+                  loader_->instance_size() != kPositionNotSpecified);
 
   if (success) {
     total_bytes_ = loader_->instance_size();
-    streaming_ = !assume_fully_buffered_ &&
+    streaming_ =
+        !assume_fully_buffered() &&
         (total_bytes_ == kPositionNotSpecified || !loader_->range_supported());
 
     media_log_->SetDoubleProperty("total_bytes",
                                   static_cast<double>(total_bytes_));
     media_log_->SetBooleanProperty("streaming", streaming_);
   } else {
     loader_->Stop();
   }
 
   // TODO(scherkus): we shouldn't have to lock to signal host(), see
   // http://crbug.com/113712 for details.
   base::AutoLock auto_lock(lock_);
   if (stop_signal_received_)
     return;
 
   if (success) {
     if (total_bytes_ != kPositionNotSpecified) {
       host_->SetTotalBytes(total_bytes_);
-      if (assume_fully_buffered_)
+      if (assume_fully_buffered())
         host_->AddBufferedByteRange(0, total_bytes_);
     }
 
     media_log_->SetBooleanProperty("single_origin", loader_->HasSingleOrigin());
     media_log_->SetBooleanProperty("passed_cors_access_check",
                                    loader_->DidPassCORSAccessCheck());
     media_log_->SetBooleanProperty("range_header_supported",
                                    loader_->range_supported());
   }
 
@@ skipping 75 matching lines @@
                                   total_bytes_);
     }
   }
   ReadOperation::Run(read_op_.Pass(), bytes_read);
 }
 
 void BufferedDataSource::LoadingStateChangedCallback(
     BufferedResourceLoader::LoadingState state) {
   DCHECK(render_loop_->BelongsToCurrentThread());
 
-  if (assume_fully_buffered_)
+  if (assume_fully_buffered())
     return;
 
   bool is_downloading_data;
   switch (state) {
     case BufferedResourceLoader::kLoading:
       is_downloading_data = true;
       break;
     case BufferedResourceLoader::kLoadingDeferred:
     case BufferedResourceLoader::kLoadingFinished:
       is_downloading_data = false;
       break;
 
     // TODO(scherkus): we don't signal network activity changes when loads
     // fail to preserve existing behaviour when deferring is toggled, however
     // we should consider changing DownloadingCB to also propagate loading
     // state. For example there isn't any signal today to notify the client that
     // loading has failed (we only get errors on subsequent reads).
     case BufferedResourceLoader::kLoadingFailed:
       return;
   }
 
   downloading_cb_.Run(is_downloading_data);
 }
 
 void BufferedDataSource::ProgressCallback(int64 position) {
   DCHECK(render_loop_->BelongsToCurrentThread());
 
-  if (assume_fully_buffered_)
+  if (assume_fully_buffered())
     return;
 
   // TODO(scherkus): we shouldn't have to lock to signal host(), see
   // http://crbug.com/113712 for details.
   base::AutoLock auto_lock(lock_);
   if (stop_signal_received_)
     return;
 
   host_->AddBufferedByteRange(loader_->first_byte_position(), position);
 }
@@ skipping 16 matching lines @@
     return;
   }
 
   // If media is currently playing or the page indicated preload=auto,
   // use threshold strategy to enable/disable deferring when the buffer
   // is full/depleted.
   loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer);
 }
 
 }  // namespace content