Parsing filesystem url before giving it to media player

media/base/android/media_player_bridge.h

 // 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.
 
 #ifndef MEDIA_BASE_ANDROID_MEDIA_PLAYER_BRIDGE_H_
 #define MEDIA_BASE_ANDROID_MEDIA_PLAYER_BRIDGE_H_
 
 #include <jni.h>
 #include <map>
 #include <string>
 
 #include "base/android/scoped_java_ref.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
+#include "base/string_util.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "media/base/media_export.h"
 #include "media/base/android/media_player_listener.h"
 
 namespace media {
 
-class CookieGetter;
+class MediaResourceGetter;
 class MediaPlayerBridgeManager;
 
 // This class serves as a bridge for native code to call java functions inside
 // android mediaplayer class. For more information on android mediaplayer, check
 // http://developer.android.com/reference/android/media/MediaPlayer.html
 // The actual android mediaplayer instance is created lazily when Start(),
 // Pause(), SeekTo() gets called. As a result, media information may not
 // be available until one of those operations is performed. After that, we
 // will cache those information in case the mediaplayer gets released.
 class MEDIA_EXPORT MediaPlayerBridge {
@@ skipping 33 matching lines @@
   typedef base::Callback<void(int, base::TimeDelta)> TimeUpdateCB;
 
   static bool RegisterMediaPlayerBridge(JNIEnv* env);
 
   // Construct a MediaPlayerBridge object with all the needed media player
   // callbacks. This object needs to call |manager|'s RequestMediaResources()
   // before decoding the media stream. This allows |manager| to track
   // unused resources and free them when needed. On the other hand, it needs
   // to call ReleaseMediaResources() when it is done with decoding.
   MediaPlayerBridge(int player_id,
                     const std::string& url,

[scherkus (not reviewing), 2013/03/08 21:26:27]

hmm... it'd be nice to use a GURL instead of a string for URL

is it a big change to get this updated? that way you can use GURL::SchemeIs()
and avoid your own string parsing code

[qinmin, 2013/03/08 22:36:12]

Fixed. 
I remember I tried to use GURL in the past. But somehow media/ does not have
dependencies on googleurl. Even today, GURL is not used anywhere in media/. 
Just checked media.gyp, looks like the dependency is fixed. But the wierd thing
is that we don't use it anywhere.

On 2013/03/08 21:26:27, scherkus wrote:

                     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 44 matching lines @@
   void OnMediaInterrupted();
 
   // Prepare the player for playback, asynchronously. When succeeds,
   // OnMediaPrepared() will be called. Otherwise, OnMediaError() will
   // be called with an error type.
   void Prepare();
 
   // Callback function passed to |cookies_retriever_|.
   void GetCookiesCallback(const std::string& cookies);
 
+  // Set the data source for the media player.
+  void SetDataSource(const std::string& url);
+
   int player_id() { return player_id_; }
   bool can_pause() { return can_pause_; }
   bool can_seek_forward() { return can_seek_forward_; }
   bool can_seek_backward() { return can_seek_backward_; }
   bool prepared() { return prepared_; }
 
  private:
   // Create the actual android media player.
   void InitializePlayer();
 
@@ skipping 41 matching lines @@
   // Stats about the media.
   base::TimeDelta duration_;
   int width_;
   int height_;
 
   // Meta data about actions can be taken.
   bool can_pause_;
   bool can_seek_forward_;
   bool can_seek_backward_;
 
   // Cookies for |url_|

[scherkus (not reviewing), 2013/03/08 21:26:27]

nit: this should end w/ period

[qinmin, 2013/03/08 22:36:12]

Done.

   std::string cookies_;
 
   // Resource manager for all the media players.
   MediaPlayerBridgeManager* manager_;
 
-  // Object for retrieving cookies for this media player.
-  scoped_ptr<CookieGetter> cookie_getter_;
+  // Object for retrieving resources for this media player.
+  scoped_ptr<MediaResourceGetter> resource_getter_;
 
   // Java MediaPlayer instance.
   base::android::ScopedJavaGlobalRef<jobject> j_media_player_;
 
   base::RepeatingTimer<MediaPlayerBridge> time_update_timer_;
 
   // Weak pointer passed to |listener_| for callbacks.
   base::WeakPtrFactory<MediaPlayerBridge> weak_this_;
 
   // Listener object that listens to all the media player events.
   MediaPlayerListener listener_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaPlayerBridge);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_ANDROID_MEDIA_PLAYER_BRIDGE_H_