Add CORS-awareness to HTML5 media elements.

This CL is dead code until WebMediaPlayerClientImpl starts calling the new 2-arg
load() method, but this needs to land (and roll into WebKit DEPS) before WMPCI
can be updated to call this 2-arg load().

BUG=123369


Review URL: https://chromiumcodereview.appspot.com/10543007

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@140779 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 76 insertions, 20 deletions

diff --git a/webkit/media/android/webmediaplayer_android.cc b/webkit/media/android/webmediaplayer_android.cc
index faaadaf..a0f865e 100644
--- a/webkit/media/android/webmediaplayer_android.cc
+++ b/webkit/media/android/webmediaplayer_android.cc
@@ -99,6 +99,13 @@ void WebMediaPlayerAndroid::InitIncognito(bool incognito_mode) {
 }
 
 void WebMediaPlayerAndroid::load(const WebURL& url) {
+  load(url, CORSModeUnspecified);
+}
+
+void WebMediaPlayerAndroid::load(const WebURL& url, CORSMode cors_mode) {
+  if (cors_mode != CORSModeUnspecified)
+    NOTIMPLEMENTED() << "No CORS support";
+
   url_ = url;
 
   UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
diff --git a/webkit/media/android/webmediaplayer_android.h b/webkit/media/android/webmediaplayer_android.h
index b948d362..2f608ae 100644
--- a/webkit/media/android/webmediaplayer_android.h
+++ b/webkit/media/android/webmediaplayer_android.h
@@ -50,8 +50,11 @@ class WebMediaPlayerAndroid :
   // Set |incognito_mode_| to true if in incognito mode.
   static void InitIncognito(bool incognito_mode);
 
-  // Resource loading.
+  // TODO(fischman): remove the single-param version once WebKit stops calling
+  // it.
   virtual void load(const WebKit::WebURL& url);
+  // Resource loading.
+  virtual void load(const WebKit::WebURL& url, CORSMode cors_mode);
   virtual void cancelLoad();
 
   // Playback controls.
diff --git a/webkit/media/buffered_data_source.cc b/webkit/media/buffered_data_source.cc
index 9e87ca0..5493959 100644
--- a/webkit/media/buffered_data_source.cc
+++ b/webkit/media/buffered_data_source.cc
@@ -62,6 +62,7 @@ BufferedResourceLoader* BufferedDataSource::CreateResourceLoader(
       BufferedResourceLoader::kThresholdDefer;
 
   return new BufferedResourceLoader(url_,
+                                    cors_mode_,
                                     first_byte_position,
                                     last_byte_position,
                                     strategy,
@@ -81,11 +82,13 @@ void BufferedDataSource::set_host(media::DataSourceHost* host) {
 
 void BufferedDataSource::Initialize(
     const GURL& url,
+    BufferedResourceLoader::CORSMode cors_mode,
     const media::PipelineStatusCB& initialize_cb) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(!initialize_cb.is_null());
   DCHECK(!loader_.get());
   url_ = url;
+  cors_mode_ = cors_mode;
 
   initialize_cb_ = initialize_cb;
 
diff --git a/webkit/media/buffered_data_source.h b/webkit/media/buffered_data_source.h
index fd97592..7e743d1 100644
--- a/webkit/media/buffered_data_source.h
+++ b/webkit/media/buffered_data_source.h
@@ -35,12 +35,14 @@ class BufferedDataSource : public media::DataSource {
                      WebKit::WebFrame* frame,
                      media::MediaLog* media_log);
 
-  // Initialize this object using |url|. This object calls |status_cb| when
-  // initialization has completed.
+  // Initialize this object using |url| and |cors_mode|, and call |status_cb|
+  // when initialization has completed.
   //
   // Method called on the render thread.
-  void Initialize(const GURL& url,
-                  const media::PipelineStatusCB& status_cb);
+  void Initialize(
+      const GURL& url,
+      BufferedResourceLoader::CORSMode cors_mode,
+      const media::PipelineStatusCB& status_cb);
 
   // Adjusts the buffering algorithm based on the given preload value.
   void SetPreload(Preload preload);
@@ -139,6 +141,8 @@ class BufferedDataSource : public media::DataSource {
 
   // URL of the resource requested.
   GURL url_;
+  // crossorigin attribute on the corresponding HTML media element, if any.
+  BufferedResourceLoader::CORSMode cors_mode_;
 
   // Members for total bytes of the requested object. It is written once on
   // render thread but may be read from any thread. However reading of this
diff --git a/webkit/media/buffered_data_source_unittest.cc b/webkit/media/buffered_data_source_unittest.cc
index a7203ce..b8a88ac2 100644
--- a/webkit/media/buffered_data_source_unittest.cc
+++ b/webkit/media/buffered_data_source_unittest.cc
@@ -97,6 +97,7 @@ class BufferedDataSourceTest : public testing::Test {
   void Initialize(media::PipelineStatus expected) {
     ExpectCreateResourceLoader();
     data_source_->Initialize(response_generator_.gurl(),
+                             BufferedResourceLoader::kUnspecified,
                              media::NewExpectedStatusCB(expected));
     message_loop_.RunAllPending();
   }
diff --git a/webkit/media/buffered_resource_loader.cc b/webkit/media/buffered_resource_loader.cc
index c552cba..5bff9f0 100644
--- a/webkit/media/buffered_resource_loader.cc
+++ b/webkit/media/buffered_resource_loader.cc
@@ -105,6 +105,7 @@ static void ComputeTargetBufferWindow(float playback_rate, int bitrate,
 
 BufferedResourceLoader::BufferedResourceLoader(
     const GURL& url,
+    CORSMode cors_mode,
     int64 first_byte_position,
     int64 last_byte_position,
     DeferStrategy strategy,
@@ -118,6 +119,7 @@ BufferedResourceLoader::BufferedResourceLoader(
       range_supported_(false),
       saved_forward_capacity_(0),
       url_(url),
+      cors_mode_(cors_mode),
       first_byte_position_(first_byte_position),
       last_byte_position_(last_byte_position),
       single_origin_(true),
@@ -184,9 +186,15 @@ void BufferedResourceLoader::Start(
     loader = test_loader_.Pass();
   } else {
     WebURLLoaderOptions options;
-    options.allowCredentials = true;
-    options.crossOriginRequestPolicy =
-        WebURLLoaderOptions::CrossOriginRequestPolicyAllow;
+    if (cors_mode_ == kUnspecified) {
+      options.crossOriginRequestPolicy =
+          WebURLLoaderOptions::CrossOriginRequestPolicyAllow;
+    } else {
+      options.crossOriginRequestPolicy =
+          WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl;
+      if (cors_mode_ == kUseCredentials)
+        options.allowCredentials = true;
+    }
     loader.reset(frame->createAssociatedURLLoader(options));
   }
 
@@ -526,7 +534,10 @@ void BufferedResourceLoader::didFail(
     WebURLLoader* loader,
     const WebURLError& error) {
   DVLOG(1) << "didFail: reason=" << error.reason
-           << " isCancellation=" << error.isCancellation;
+           << ", isCancellation=" << error.isCancellation
+           << ", domain=" << error.domain.utf8().data()
+           << ", localizedDescription="
+           << error.localizedDescription.utf8().data();
   DCHECK(active_loader_.get());
 
   // We don't need to continue loading after failure.
diff --git a/webkit/media/buffered_resource_loader.h b/webkit/media/buffered_resource_loader.h
index 83a2f5d..d9fe653 100644
--- a/webkit/media/buffered_resource_loader.h
+++ b/webkit/media/buffered_resource_loader.h
@@ -65,7 +65,11 @@ class BufferedResourceLoader : public WebKit::WebURLLoaderClient {
     kCacheMiss,
   };
 
+  // Keep in sync with WebMediaPlayer::CORSMode.
+  enum CORSMode { kUnspecified, kAnonymous, kUseCredentials };
+
   // |url| - URL for the resource to be loaded.
+  // |cors_mode| - HTML media element's crossorigin attribute.
   // |first_byte_position| - First byte to start loading from,
   // |kPositionNotSpecified| for not specified.
   // |last_byte_position| - Last byte to be loaded,
@@ -73,13 +77,15 @@ class BufferedResourceLoader : public WebKit::WebURLLoaderClient {
   // |strategy| is the initial loading strategy to use.
   // |bitrate| is the bitrate of the media, 0 if unknown.
   // |playback_rate| is the current playback rate of the media.
-  BufferedResourceLoader(const GURL& url,
-                         int64 first_byte_position,
-                         int64 last_byte_position,
-                         DeferStrategy strategy,
-                         int bitrate,
-                         float playback_rate,
-                         media::MediaLog* media_log);
+  BufferedResourceLoader(
+      const GURL& url,
+      CORSMode cors_mode,
+      int64 first_byte_position,
+      int64 last_byte_position,
+      DeferStrategy strategy,
+      int bitrate,
+      float playback_rate,
+      media::MediaLog* media_log);
   virtual ~BufferedResourceLoader();
 
   // Start the resource loading with the specified URL and range.
@@ -284,6 +290,7 @@ class BufferedResourceLoader : public WebKit::WebURLLoaderClient {
   size_t saved_forward_capacity_;
 
   GURL url_;
+  CORSMode cors_mode_;
   const int64 first_byte_position_;
   const int64 last_byte_position_;
   bool single_origin_;
diff --git a/webkit/media/buffered_resource_loader_unittest.cc b/webkit/media/buffered_resource_loader_unittest.cc
index 541c5a8..9e62842 100644
--- a/webkit/media/buffered_resource_loader_unittest.cc
+++ b/webkit/media/buffered_resource_loader_unittest.cc
@@ -84,7 +84,8 @@ class BufferedResourceLoaderTest : public testing::Test {
     last_position_ = last_position;
 
     loader_.reset(new BufferedResourceLoader(
-        gurl_, first_position_, last_position_,
+        gurl_, BufferedResourceLoader::kUnspecified,
+        first_position_, last_position_,
         BufferedResourceLoader::kThresholdDefer, 0, 0,
         new media::MediaLog()));
 
diff --git a/webkit/media/webmediaplayer_impl.cc b/webkit/media/webmediaplayer_impl.cc
index d42a359..8e335a6 100644
--- a/webkit/media/webmediaplayer_impl.cc
+++ b/webkit/media/webmediaplayer_impl.cc
@@ -82,6 +82,15 @@ const float kMaxRate = 16.0f;
 
 namespace webkit_media {
 
+#define COMPILE_ASSERT_MATCHING_ENUM(name)                              \
+  COMPILE_ASSERT(static_cast<int>(WebKit::WebMediaPlayer::CORSMode ## name) == \
+                 static_cast<int>(BufferedResourceLoader::k ## name),   \
+                 mismatching_enums)
+COMPILE_ASSERT_MATCHING_ENUM(Unspecified);
+COMPILE_ASSERT_MATCHING_ENUM(Anonymous);
+COMPILE_ASSERT_MATCHING_ENUM(UseCredentials);
+#undef COMPILE_ASSERT_MATCHING_ENUM
+
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     WebKit::WebFrame* frame,
     WebKit::WebMediaPlayerClient* client,
@@ -201,6 +210,10 @@ URLSchemeForHistogram URLScheme(const GURL& url) {
 }  // anonymous namespace
 
 void WebMediaPlayerImpl::load(const WebKit::WebURL& url) {
+  load(url, CORSModeUnspecified);
+}
+
+void WebMediaPlayerImpl::load(const WebKit::WebURL& url, CORSMode cors_mode) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   GURL gurl(url);
@@ -237,9 +250,11 @@ void WebMediaPlayerImpl::load(const WebKit::WebURL& url) {
   // Otherwise it's a regular request which requires resolving the URL first.
   proxy_->set_data_source(
       new BufferedDataSource(main_loop_, frame_, media_log_));
-  proxy_->data_source()->Initialize(url, base::Bind(
-      &WebMediaPlayerImpl::DataSourceInitialized,
-      base::Unretained(this), gurl));
+  proxy_->data_source()->Initialize(
+      url, static_cast<BufferedResourceLoader::CORSMode>(cors_mode),
+      base::Bind(
+          &WebMediaPlayerImpl::DataSourceInitialized,
+          base::Unretained(this), gurl));
 
   is_local_source_ = !gurl.SchemeIs("http") && !gurl.SchemeIs("https");
 
@@ -367,6 +382,7 @@ void WebMediaPlayerImpl::setVisible(bool visible) {
 COMPILE_ASSERT_MATCHING_ENUM(PreloadNone, NONE);
 COMPILE_ASSERT_MATCHING_ENUM(PreloadMetaData, METADATA);
 COMPILE_ASSERT_MATCHING_ENUM(PreloadAuto, AUTO);
+#undef COMPILE_ASSERT_MATCHING_ENUM
 
 void WebMediaPlayerImpl::setPreload(WebMediaPlayer::Preload preload) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
diff --git a/webkit/media/webmediaplayer_impl.h b/webkit/media/webmediaplayer_impl.h
index 3b755be..7368f3a 100644
--- a/webkit/media/webmediaplayer_impl.h
+++ b/webkit/media/webmediaplayer_impl.h
@@ -110,7 +110,10 @@ class WebMediaPlayerImpl
                      media::MediaLog* media_log);
   virtual ~WebMediaPlayerImpl();
 
+  // TODO(fischman): remove the single-param version once WebKit stops calling
+  // it.
   virtual void load(const WebKit::WebURL& url);
+  virtual void load(const WebKit::WebURL& url, CORSMode cors_mode);
   virtual void cancelLoad();
 
   // Playback controls.