android: Implement single origin and CORS check for video

webkit/renderer/media/android/webmediaplayer_android.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 "webkit/renderer/media/android/webmediaplayer_android.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 105 matching lines @@
     main_loop_->RemoveDestructionObserver(this);
 }
 
 void WebMediaPlayerAndroid::load(const WebURL& url, CORSMode cors_mode) {
   load(url, NULL, cors_mode);
 }
 
 void WebMediaPlayerAndroid::load(const WebURL& url,
                                  WebMediaSource* media_source,
                                  CORSMode cors_mode) {
-  if (cors_mode != CORSModeUnspecified)
-    NOTIMPLEMENTED() << "No CORS support";
+  url_ = url;
 
   if (media_source) {
     media_source_delegate_.reset(
         new MediaSourceDelegate(proxy_, player_id_, media_log_));
     // |media_source_delegate_| is owned, so Unretained() is safe here.
     media_source_delegate_->Initialize(
         media_source,
         base::Bind(&WebMediaPlayerAndroid::OnNeedKey, base::Unretained(this)),
         base::Bind(&WebMediaPlayerAndroid::UpdateNetworkState,
                    base::Unretained(this)));
-  }
-
-  url_ = url;
-  GURL first_party_url = frame_->document().firstPartyForCookies();
-  if (proxy_) {
-    proxy_->Initialize(player_id_, url_, media_source != NULL, first_party_url);
-    if (manager_->IsInFullscreen(frame_))
-      proxy_->EnterFullscreen(player_id_);
+    InitializeProxy(true);
+  } else {
+    info_loader_.reset(
+        new MediaInfoLoaderAndroid(
+            url_,
+            cors_mode,
+            base::Bind(&WebMediaPlayerAndroid::DidLoadMediaInfo,
+                       base::Unretained(this))));
+    info_loader_->Start(frame_);
   }
 
   UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
   UpdateReadyState(WebMediaPlayer::ReadyStateHaveNothing);
 }
 
+void WebMediaPlayerAndroid::DidLoadMediaInfo(
+    MediaInfoLoaderAndroid::Status status) {
+  DCHECK(!media_source_delegate_);
+  if (status == MediaInfoLoaderAndroid::kFailed) {
+    info_loader_.reset();
+    return;
+  }
+
+  InitializeProxy(false);
+}
+
+void WebMediaPlayerAndroid::InitializeProxy(bool is_media_source) {
+  GURL first_party_url = frame_->document().firstPartyForCookies();
+  if (proxy_) {
+    proxy_->Initialize(player_id_, url_, is_media_source, first_party_url);
+    if (manager_->IsInFullscreen(frame_))
+      proxy_->EnterFullscreen(player_id_);
+  }
+}
+
 void WebMediaPlayerAndroid::cancelLoad() {
-  NOTIMPLEMENTED();
+  info_loader_.reset();
 }
 
 void WebMediaPlayerAndroid::play() {
 #if defined(GOOGLE_TV)
   if (hasVideo() && needs_external_surface_) {
     DCHECK(!needs_establish_peer_);
     if (proxy_)
       proxy_->RequestExternalSurface(player_id_, last_computed_rect_);
   }
 #endif
@@ skipping 173 matching lines @@
   web_graphics_context->copyTextureCHROMIUM(GL_TEXTURE_2D, texture_id_,
                                             texture, level, internal_format,
                                             type);
   web_graphics_context->pixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, false);
   web_graphics_context->pixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM,
                                     false);
   return true;
 }
 
 bool WebMediaPlayerAndroid::hasSingleSecurityOrigin() const {
-  // TODO(qinmin): fix this for urls that are not file.
-  // https://code.google.com/p/chromium/issues/detail?id=234710
-  if (url_.SchemeIsFile())
-    return true;
+  if (info_loader_)
+    return info_loader_->HasSingleOrigin();
   return false;

[Ken Russell (switch to Gerrit), 2013/06/05 18:33:50]

Should this return true? WebMediaPlayerImpl::hasSingleSecurityOrigin returns
true in the fall-through case. What case does that handle? getUserMedia with a
webcam's input?

[Sami, 2013/06/06 12:29:48]

This path is reached when we're playing from a media source/stream. I tested
that the getUserMedia webcam case goes through webmediaplayer_ms.cc so I'm not
exactly sure when we end up here. I'll change this to be consistent with
WebMediaPlayerImpl.

 }
 
 bool WebMediaPlayerAndroid::didPassCORSAccessCheck() const {
+  if (info_loader_)
+    return info_loader_->DidPassCORSAccessCheck();
   return false;
 }
 
 WebMediaPlayer::MovieLoadType WebMediaPlayerAndroid::movieLoadType() const {
   // Deprecated.
   // TODO(qinmin): Remove this from WebKit::WebMediaPlayer as it is never used.
   return WebMediaPlayer::MovieLoadTypeUnknown;
 }
 
 double WebMediaPlayerAndroid::mediaTimeForTimeValue(double timeValue) const {
@@ skipping 595 matching lines @@
 void WebMediaPlayerAndroid::exitFullscreen() {
   if (proxy_)
     proxy_->ExitFullscreen(player_id_);
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
   return manager_->CanEnterFullscreen(frame_);
 }
 
 }  // namespace webkit_media