Parsing filesystem url before giving it to media player

media/base/android/media_player_bridge.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 "media/base/android/media_player_bridge.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/message_loop_proxy.h"
 #include "jni/MediaPlayerBridge_jni.h"
 #include "jni/MediaPlayer_jni.h"
-#include "media/base/android/cookie_getter.h"
 #include "media/base/android/media_player_bridge_manager.h"
+#include "media/base/android/media_resource_getter.h"
 
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ScopedJavaLocalRef;
 
 // Time update happens every 250ms.
 static const int kTimeUpdateInterval = 250;
 
 // Because we create the media player lazily on android, the duration of the
 // media is initially unknown to us. This makes the user unable to perform
 // seek. To solve this problem, we use a temporary duration of 100 seconds when
 // the duration is unknown. And we scale the seek position later when duration
 // is available.
 // TODO(qinmin): create a thread and use android MediaMetadataRetriever
 // class to extract the duration.
 static const int kTemporaryDuration = 100;
 
 namespace media {
 
 MediaPlayerBridge::MediaPlayerBridge(
     int player_id,
-    const std::string& url,
-    const std::string& first_party_for_cookies,
-    CookieGetter* cookie_getter,
+    const GURL& url,
+    const GURL& first_party_for_cookies,
+    MediaResourceGetter* resource_getter,
     bool hide_url_log,
     MediaPlayerBridgeManager* manager,
     const MediaErrorCB& media_error_cb,
     const VideoSizeChangedCB& video_size_changed_cb,
     const BufferingUpdateCB& buffering_update_cb,
     const MediaPreparedCB& media_prepared_cb,
     const PlaybackCompleteCB& playback_complete_cb,
     const SeekCompleteCB& seek_complete_cb,
     const TimeUpdateCB& time_update_cb,
     const MediaInterruptedCB& media_interrupted_cb)
     : media_error_cb_(media_error_cb),
       video_size_changed_cb_(video_size_changed_cb),
       buffering_update_cb_(buffering_update_cb),
       media_prepared_cb_(media_prepared_cb),
       playback_complete_cb_(playback_complete_cb),
       seek_complete_cb_(seek_complete_cb),
       media_interrupted_cb_(media_interrupted_cb),
       time_update_cb_(time_update_cb),
       player_id_(player_id),
       prepared_(false),
       pending_play_(false),
       url_(url),
       first_party_for_cookies_(first_party_for_cookies),
-      has_cookies_(false),
       hide_url_log_(hide_url_log),
       duration_(base::TimeDelta::FromSeconds(kTemporaryDuration)),
       width_(0),
       height_(0),
       can_pause_(true),
       can_seek_forward_(true),
       can_seek_backward_(true),
       manager_(manager),
-      cookie_getter_(cookie_getter),
+      resource_getter_(resource_getter),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_this_(this)),
       listener_(base::MessageLoopProxy::current(),
-                weak_this_.GetWeakPtr()) {}
+                weak_this_.GetWeakPtr()) {
+  has_cookies_ = url_.SchemeIsFileSystem() || url_.SchemeIsFile();
+}
 
 MediaPlayerBridge::~MediaPlayerBridge() {
   Release();
 }
 
 void MediaPlayerBridge::InitializePlayer() {
   JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
 
   j_media_player_.Reset(JNI_MediaPlayer::Java_MediaPlayer_Constructor(env));
@@ skipping 15 matching lines @@
       env, j_media_player_.obj(), surface);
 }
 
 void MediaPlayerBridge::Prepare() {
   if (j_media_player_.is_null())
     InitializePlayer();
 
   if (has_cookies_) {
     GetCookiesCallback(cookies_);
   } else {
-    cookie_getter_->GetCookies(url_, first_party_for_cookies_, base::Bind(
+    resource_getter_->GetCookies(url_, first_party_for_cookies_, base::Bind(
         &MediaPlayerBridge::GetCookiesCallback, weak_this_.GetWeakPtr()));
   }
 }
 
 void MediaPlayerBridge::GetCookiesCallback(const std::string& cookies) {
   cookies_ = cookies;
   has_cookies_ = true;
+
   if (j_media_player_.is_null())
     return;
 
+  if (url_.SchemeIsFileSystem()) {
+    resource_getter_->GetPlatformPathFromFileSystemURL(url_, base::Bind(
+        &MediaPlayerBridge::SetDataSource, weak_this_.GetWeakPtr()));
+  } else {
+    SetDataSource(url_.spec());
+  }
+}
+
+void MediaPlayerBridge::SetDataSource(const std::string& url) {
+  if (j_media_player_.is_null())
+    return;
+
   JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
 
   // Create a Java String for the URL.
-  ScopedJavaLocalRef<jstring> j_url_string = ConvertUTF8ToJavaString(env, url_);
+  ScopedJavaLocalRef<jstring> j_url_string = ConvertUTF8ToJavaString(env, url);
   ScopedJavaLocalRef<jstring> j_cookies = ConvertUTF8ToJavaString(
       env, cookies_);
 
   jobject j_context = base::android::GetApplicationContext();
   DCHECK(j_context);
 
   if (Java_MediaPlayerBridge_setDataSource(
       env, j_media_player_.obj(), j_context, j_url_string.obj(),
       j_cookies.obj(), hide_url_log_)) {
     if (manager_)
@@ skipping 217 matching lines @@
 
 bool MediaPlayerBridge::RegisterMediaPlayerBridge(JNIEnv* env) {
   bool ret = RegisterNativesImpl(env);
   DCHECK(g_MediaPlayerBridge_clazz);
   if (ret)
     ret = JNI_MediaPlayer::RegisterNativesImpl(env);
   return ret;
 }
 
 }  // namespace media