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::AttachCurrentThread;
 using base::android::CheckException;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::GetClass;
 using base::android::JavaRef;
 using base::android::MethodID;
 using base::android::ScopedJavaLocalRef;
 
 // These constants are from the android source tree and need to be kept in
@@ skipping 13 matching lines @@
 // 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,
+    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)
@@ skipping 12 matching lines @@
       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()) {}
 
 MediaPlayerBridge::~MediaPlayerBridge() {
   Release();
 }
 
 void MediaPlayerBridge::InitializePlayer() {
   JNIEnv* env = AttachCurrentThread();
@@ skipping 18 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 (StartsWithASCII(url_, "filesystem", false)) {
+    resource_getter_->GetPlatformPathFromFileSystemURL(url_, base::Bind(
+        &MediaPlayerBridge::SetDataSource, weak_this_.GetWeakPtr()));
+  } else {
+    SetDataSource(url_);
+  }
+}
+
+void MediaPlayerBridge::SetDataSource(const std::string& url) {
+  if (j_media_player_.is_null())
+    return;
+
   JNIEnv* env = 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 238 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