Add CORS-awareness to HTML5 media elements.

webkit/media/webmediaplayer_impl.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 "webkit/media/webmediaplayer_impl.h"
 
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 63 matching lines @@
 // Also our timers are not very accurate (especially for ogg), which becomes
 // evident at low speeds and on Vista. Since other speeds are risky and outside
 // the norms, we think 1/16x to 16x is a safe and useful range for now.
 const float kMinRate = 0.0625f;
 const float kMaxRate = 16.0f;
 
 }  // namespace
 
 namespace webkit_media {
 
+#define COMPILE_ASSERT_MATCHING_ENUM(name)                              \
+  COMPILE_ASSERT(static_cast<int>(WebKit::WebMediaPlayer::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,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
     media::FilterCollection* collection,
     WebKit::WebAudioSourceProvider* audio_source_provider,
     media::MessageLoopFactory* message_loop_factory,
     MediaStreamClient* media_stream_client,
     media::MediaLog* media_log)
     : frame_(frame),
@@ skipping 97 matching lines @@
   if (url.SchemeIs("file")) return kFileURLScheme;
   if (url.SchemeIs("blob")) return kBlobURLScheme;
   if (url.SchemeIs("data")) return kDataURLScheme;
   if (url.SchemeIs("filesystem")) return kFileSystemScheme;
   return kUnknownURLScheme;
 }
 
 }  // anonymous namespace
 
 void WebMediaPlayerImpl::load(const WebKit::WebURL& url) {
+  load(url, Unspecified);
+}
+
+void WebMediaPlayerImpl::load(const WebKit::WebURL& url,
+                              CrossOriginAttribute cross_origin_attribute) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   GURL gurl(url);
   UMA_HISTOGRAM_ENUMERATION("Media.URLScheme", URLScheme(gurl), kMaxURLScheme);
 
   // Handle any volume/preload changes that occured before load().
   setVolume(GetClient()->volume());
   setPreload(GetClient()->preload());
 
   SetNetworkState(WebMediaPlayer::NetworkStateLoading);
   SetReadyState(WebMediaPlayer::ReadyStateHaveNothing);
   media_log_->AddEvent(media_log_->CreateLoadEvent(url.spec()));
 
   // Media streams pipelines can start immediately.
   if (BuildMediaStreamCollection(url, media_stream_client_,
                                  message_loop_factory_.get(),
                                  filter_collection_.get())) {
+    DCHECK_EQ(cross_origin_attribute, Unspecified);

[scherkus (not reviewing), 2012/06/06 00:44:36]

so adding a crossorigin attribute to a media stream <video> in debug build will
crash? that doesn't seem very nice :(

[Ami GONE FROM CHROMIUM, 2012/06/06 00:59:29]

Done.

     StartPipeline();
     return;
   }
 
   // Media source pipelines can start immediately.
   scoped_refptr<media::FFmpegVideoDecoder> video_decoder;
   if (BuildMediaSourceCollection(url, GetClient()->sourceURL(), proxy_,
                                  message_loop_factory_.get(),
                                  filter_collection_.get(),
                                  &video_decoder)) {
+    DCHECK_EQ(cross_origin_attribute, Unspecified);
     proxy_->set_video_decoder(video_decoder);
     StartPipeline();
     return;
   }
 
   // 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::CrossOriginAttribute>(
+          cross_origin_attribute),
+      base::Bind(
+          &WebMediaPlayerImpl::DataSourceInitialized,
+          base::Unretained(this), gurl));
 
   is_local_source_ = !gurl.SchemeIs("http") && !gurl.SchemeIs("https");
 
   BuildDefaultCollection(proxy_->data_source(),
                          message_loop_factory_.get(),
                          filter_collection_.get(),
                          &video_decoder);
   proxy_->set_video_decoder(video_decoder);
 }
 
@@ skipping 106 matching lines @@
   return;
 }
 
 #define COMPILE_ASSERT_MATCHING_ENUM(webkit_name, chromium_name) \
     COMPILE_ASSERT(static_cast<int>(WebMediaPlayer::webkit_name) == \
                    static_cast<int>(webkit_media::chromium_name), \
                    mismatching_enums)
 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());
 
   if (proxy_ && proxy_->data_source()) {
     // XXX: Why do I need to use webkit_media:: prefix? clang complains!
     proxy_->data_source()->SetPreload(
         static_cast<webkit_media::Preload>(preload));
   }
 }
@@ skipping 657 matching lines @@
   return audio_source_provider_;
 }
 
 void WebMediaPlayerImpl::IncrementExternallyAllocatedMemory() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   incremented_externally_allocated_memory_ = true;
   v8::V8::AdjustAmountOfExternalAllocatedMemory(kPlayerExtraMemory);
 }
 
 }  // namespace webkit_media