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 60 matching lines @@
       pending_seek_(0),
       seeking_(false),
       did_loading_progress_(false),
       manager_(manager),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       is_playing_(false),
       needs_establish_peer_(true),
       stream_texture_proxy_initialized_(false),
       has_size_info_(false),
+      has_media_metadata_(false),
+      has_media_info_(false),
       stream_texture_factory_(factory),
       needs_external_surface_(false),
       video_frame_provider_client_(NULL),
       source_type_(MediaPlayerAndroid::SOURCE_TYPE_URL),
       proxy_(proxy),
       current_time_(0),
       media_log_(media_log),
       media_stream_client_(NULL) {
   DCHECK(proxy_);
 
@@ skipping 60 matching lines @@
 #endif
 }
 
 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";
-
   source_type_ = MediaPlayerAndroid::SOURCE_TYPE_URL;
+  has_media_metadata_ = false;
+  has_media_info_ = false;
 
   if (media_source)
     source_type_ = MediaPlayerAndroid::SOURCE_TYPE_MSE;
 #if defined(GOOGLE_TV)
   if (media_stream_client_) {
     DCHECK(!media_source);
     source_type_ = MediaPlayerAndroid::SOURCE_TYPE_STREAM;
   }
 #endif
 
   if (source_type_ != MediaPlayerAndroid::SOURCE_TYPE_URL) {
+    has_media_info_ = true;
     media_source_delegate_.reset(
         new MediaSourceDelegate(proxy_, player_id_, media_log_));
     // |media_source_delegate_| is owned, so Unretained() is safe here.
     if (source_type_ == MediaPlayerAndroid::SOURCE_TYPE_MSE) {
       media_source_delegate_->InitializeMediaSource(
           media_source,
           base::Bind(&WebMediaPlayerAndroid::OnNeedKey, base::Unretained(this)),
           base::Bind(&WebMediaPlayerAndroid::UpdateNetworkState,
                      base::Unretained(this)),
           BIND_TO_RENDER_LOOP(&WebMediaPlayerAndroid::OnDurationChange));
     }
 #if defined(GOOGLE_TV)
     if (source_type_ == MediaPlayerAndroid::SOURCE_TYPE_STREAM) {
       media_source_delegate_->InitializeMediaStream(
           demuxer_,
           base::Bind(&WebMediaPlayerAndroid::UpdateNetworkState,
                      base::Unretained(this)));
       audio_renderer_ = media_stream_client_->GetAudioRenderer(url);
       if (audio_renderer_)
         audio_renderer_->Start();
     }
 #endif
+  } else {
+    info_loader_.reset(
+        new MediaInfoLoader(
+            url,
+            cors_mode,
+            base::Bind(&WebMediaPlayerAndroid::DidLoadMediaInfo,
+                       base::Unretained(this))));
+    info_loader_->Start(frame_);
   }
 
   InitializeMediaPlayer(url);
 }
 
 void WebMediaPlayerAndroid::InitializeMediaPlayer(const WebURL& url) {
   url_ = url;
   GURL first_party_url = frame_->document().firstPartyForCookies();
   proxy_->Initialize(player_id_, url, source_type_, first_party_url);
   if (manager_->IsInFullscreen(frame_))
     proxy_->EnterFullscreen(player_id_);
 
   UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
   UpdateReadyState(WebMediaPlayer::ReadyStateHaveNothing);
 }
 
+void WebMediaPlayerAndroid::DidLoadMediaInfo(
+    MediaInfoLoader::Status status) {
+  DCHECK(!media_source_delegate_);
+  if (status == MediaInfoLoader::kFailed) {
+    info_loader_.reset();
+    UpdateNetworkState(WebMediaPlayer::NetworkStateNetworkError);
+    return;
+  }
+
+  has_media_info_ = true;
+  if (has_media_metadata_ &&
+      ready_state_ != WebMediaPlayer::ReadyStateHaveEnoughData) {
+    UpdateReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
+    UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
+  }
+}
+
 void WebMediaPlayerAndroid::play() {
 #if defined(GOOGLE_TV)
   if (hasVideo() && needs_external_surface_) {
     DCHECK(!needs_establish_peer_);
     proxy_->RequestExternalSurface(player_id_, last_computed_rect_);
   }
   if (audio_renderer_ && paused())
     audio_renderer_->Play();
 #endif
   if (hasVideo() && needs_establish_peer_)
@@ skipping 161 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();
+  // The info loader may have failed.
+  if (source_type_ == MediaPlayerAndroid::SOURCE_TYPE_URL)
+    return false;
+  return true;
+}
+
+bool WebMediaPlayerAndroid::didPassCORSAccessCheck() const {
+  if (info_loader_)
+    return info_loader_->DidPassCORSAccessCheck();
   return false;
 }
 
-bool WebMediaPlayerAndroid::didPassCORSAccessCheck() const {
-  return false;
-}
-
 double WebMediaPlayerAndroid::mediaTimeForTimeValue(double timeValue) const {
   return ConvertSecondsToTimestamp(timeValue).InSecondsF();
 }
 
 unsigned WebMediaPlayerAndroid::decodedFrameCount() const {
   if (media_source_delegate_)
     return media_source_delegate_->DecodedFrameCount();
   NOTIMPLEMENTED();
   return 0;
 }
@@ skipping 38 matching lines @@
     // already triggers a durationchanged event. If this is a different
     // transition, remember to signal durationchanged.
     // Do not ever signal durationchanged on metadata change in MSE case
     // because OnDurationChange() handles this.
     if (ready_state_ > WebMediaPlayer::ReadyStateHaveNothing &&
         source_type_ != MediaPlayerAndroid::SOURCE_TYPE_MSE) {
       need_to_signal_duration_changed = true;
     }
   }
 
-  if (ready_state_ != WebMediaPlayer::ReadyStateHaveEnoughData) {
+  has_media_metadata_ = true;
+  if (has_media_info_ &&
+      ready_state_ != WebMediaPlayer::ReadyStateHaveEnoughData) {
     UpdateReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
     UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
   }
 
   // TODO(wolenetz): Should we just abort early and set network state to an
   // error if success == false? See http://crbug.com/248399
   if (success)
     OnVideoSizeChanged(width, height);
 
   if (hasVideo() && !video_weblayer_ && client_->needsWebLayerForVideo()) {
@@ skipping 607 matching lines @@
 
 void WebMediaPlayerAndroid::exitFullscreen() {
   proxy_->ExitFullscreen(player_id_);
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
   return manager_->CanEnterFullscreen(frame_);
 }
 
 }  // namespace webkit_media