content/browser/media/android/media_resource_getter_impl.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/media/android/media_resource_getter_impl.h"
   6
   7 #include "base/android/jni_android.h"
   8 #include "base/android/jni_string.h"
   9 #include "base/bind.h"
  10 #include "base/path_service.h"
  11 #include "base/threading/sequenced_worker_pool.h"
  12 #include "content/browser/child_process_security_policy_impl.h"
  13 #include "content/browser/fileapi/browser_file_system_helper.h"
  14 #include "content/browser/fileapi/chrome_blob_storage_context.h"
  15 #include "content/browser/resource_context_impl.h"
  16 #include "content/public/browser/browser_context.h"
  17 #include "content/public/browser/browser_thread.h"
  18 #include "content/public/browser/content_browser_client.h"
  19 #include "content/public/common/content_client.h"
  20 #include "content/public/common/url_constants.h"
  21 #include "jni/MediaResourceGetter_jni.h"
  22 #include "media/base/android/media_url_interceptor.h"
  23 #include "net/base/auth.h"
  24 #include "net/cookies/cookie_monster.h"
  25 #include "net/cookies/cookie_store.h"
  26 #include "net/http/http_auth.h"
  27 #include "net/http/http_transaction_factory.h"
  28 #include "net/url_request/url_request_context.h"
  29 #include "net/url_request/url_request_context_getter.h"
  30 #include "storage/browser/blob/blob_data_handle.h"
  31 #include "storage/browser/blob/blob_storage_context.h"
  32 #include "url/gurl.h"
  33
  34 using base::android::ConvertUTF8ToJavaString;
  35 using base::android::ScopedJavaLocalRef;
  36
  37 namespace content {
  38
  39 static void ReturnResultOnUIThread(
  40     const base::Callback<void(const std::string&)>& callback,
  41     const std::string& result) {
  42   BrowserThread::PostTask(
  43       BrowserThread::UI, FROM_HERE, base::Bind(callback, result));
  44 }
  45
  46 static void RequestPlatformPathFromBlobURL(
  47     const GURL& url,
  48     ResourceContext* resource_context,
  49     const base::Callback<void(const std::string&)>& callback) {
  50   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  51   ChromeBlobStorageContext* blob_storage_context =
  52       GetChromeBlobStorageContextForResourceContext(resource_context);
  53
  54   scoped_ptr<storage::BlobDataHandle> handle =
  55       blob_storage_context->context()->GetBlobDataFromPublicURL(url);
  56   if (!handle) {
  57     // There are plenty of cases where handle can be empty. The most trivial is
  58     // when JS has aready revoked the given blob URL via URL.revokeObjectURL
  59     ReturnResultOnUIThread(callback, std::string());
  60     return;
  61   }
  62   storage::BlobData* data = handle->data();
  63   if (!data) {
  64     ReturnResultOnUIThread(callback, std::string());
  65     NOTREACHED();
  66     return;
  67   }
  68   const std::vector<storage::BlobData::Item> items = data->items();
  69
  70   // TODO(qinmin): handle the case when the blob data is not a single file.
  71   DLOG_IF(WARNING, items.size() != 1u)
  72       << "More than one blob data are present: " << items.size();
  73   ReturnResultOnUIThread(callback, items[0].path().value());
  74 }
  75
  76 static void RequestPlaformPathFromFileSystemURL(
  77     const GURL& url,
  78     int render_process_id,
  79     scoped_refptr<storage::FileSystemContext> file_system_context,
  80     const base::Callback<void(const std::string&)>& callback) {
  81   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
  82   base::FilePath platform_path;
  83   SyncGetPlatformPath(file_system_context.get(),
  84                       render_process_id,
  85                       url,
  86                       &platform_path);
  87   base::FilePath data_storage_path;
  88   PathService::Get(base::DIR_ANDROID_APP_DATA, &data_storage_path);
  89   if (data_storage_path.IsParent(platform_path))
  90     ReturnResultOnUIThread(callback, platform_path.value());
  91   else
  92     ReturnResultOnUIThread(callback, std::string());
  93 }
  94
  95 // Posts a task to the UI thread to run the callback function.
  96 static void PostMediaMetadataCallbackTask(
  97     const media::MediaResourceGetter::ExtractMediaMetadataCB& callback,
  98     JNIEnv* env, ScopedJavaLocalRef<jobject>& j_metadata) {
  99   BrowserThread::PostTask(
 100         BrowserThread::UI, FROM_HERE,
 101         base::Bind(callback, base::TimeDelta::FromMilliseconds(
 102                        Java_MediaMetadata_getDurationInMilliseconds(
 103                            env, j_metadata.obj())),
 104                    Java_MediaMetadata_getWidth(env, j_metadata.obj()),
 105                    Java_MediaMetadata_getHeight(env, j_metadata.obj()),
 106                    Java_MediaMetadata_isSuccess(env, j_metadata.obj())));
 107 }
 108
 109 // Gets the metadata from a media URL. When finished, a task is posted to the UI
 110 // thread to run the callback function.
 111 static void GetMediaMetadata(
 112     const std::string& url, const std::string& cookies,
 113     const std::string& user_agent,
 114     const media::MediaResourceGetter::ExtractMediaMetadataCB& callback) {
 115   JNIEnv* env = base::android::AttachCurrentThread();
 116
 117   ScopedJavaLocalRef<jstring> j_url_string = ConvertUTF8ToJavaString(env, url);
 118   ScopedJavaLocalRef<jstring> j_cookies = ConvertUTF8ToJavaString(env, cookies);
 119   jobject j_context = base::android::GetApplicationContext();
 120   ScopedJavaLocalRef<jstring> j_user_agent = ConvertUTF8ToJavaString(
 121       env, user_agent);
 122   ScopedJavaLocalRef<jobject> j_metadata =
 123       Java_MediaResourceGetter_extractMediaMetadata(env,
 124                                                     j_context,
 125                                                     j_url_string.obj(),
 126                                                     j_cookies.obj(),
 127                                                     j_user_agent.obj());
 128
 129   PostMediaMetadataCallbackTask(callback, env, j_metadata);
 130 }
 131
 132 // Gets the metadata from a file descriptor. When finished, a task is posted to
 133 // the UI thread to run the callback function.
 134 static void GetMediaMetadataFromFd(
 135     const int fd, const int64 offset, const int64 size,
 136     const media::MediaResourceGetter::ExtractMediaMetadataCB& callback) {
 137   JNIEnv* env = base::android::AttachCurrentThread();
 138
 139   ScopedJavaLocalRef<jobject> j_metadata =
 140       Java_MediaResourceGetter_extractMediaMetadataFromFd(
 141           env, fd, offset, size);
 142
 143   PostMediaMetadataCallbackTask(callback, env, j_metadata);
 144 }
 145
 146 // The task object that retrieves media resources on the IO thread.
 147 // TODO(qinmin): refactor this class to make the code reusable by others as
 148 // there are lots of duplicated functionalities elsewhere.
 149 // http://crbug.com/395762.
 150 class MediaResourceGetterTask
 151      : public base::RefCountedThreadSafe<MediaResourceGetterTask> {
 152  public:
 153   MediaResourceGetterTask(BrowserContext* browser_context,
 154                           int render_process_id, int render_frame_id);
 155
 156   // Called by MediaResourceGetterImpl to start getting auth credentials.
 157   net::AuthCredentials RequestAuthCredentials(const GURL& url) const;
 158
 159   // Called by MediaResourceGetterImpl to start getting cookies for a URL.
 160   void RequestCookies(
 161       const GURL& url, const GURL& first_party_for_cookies,
 162       const media::MediaResourceGetter::GetCookieCB& callback);
 163
 164  private:
 165   friend class base::RefCountedThreadSafe<MediaResourceGetterTask>;
 166   virtual ~MediaResourceGetterTask();
 167
 168   void CheckPolicyForCookies(
 169       const GURL& url, const GURL& first_party_for_cookies,
 170       const media::MediaResourceGetter::GetCookieCB& callback,
 171       const net::CookieList& cookie_list);
 172
 173   // Context getter used to get the CookieStore and auth cache.
 174   net::URLRequestContextGetter* context_getter_;
 175
 176   // Resource context for checking cookie policies.
 177   ResourceContext* resource_context_;
 178
 179   // Render process id, used to check whether the process can access cookies.
 180   int render_process_id_;
 181
 182   // Render frame id, used to check tab specific cookie policy.
 183   int render_frame_id_;
 184
 185   DISALLOW_COPY_AND_ASSIGN(MediaResourceGetterTask);
 186 };
 187
 188 MediaResourceGetterTask::MediaResourceGetterTask(
 189     BrowserContext* browser_context, int render_process_id, int render_frame_id)
 190     : context_getter_(browser_context->GetRequestContext()),
 191       resource_context_(browser_context->GetResourceContext()),
 192       render_process_id_(render_process_id),
 193       render_frame_id_(render_frame_id) {
 194 }
 195
 196 MediaResourceGetterTask::~MediaResourceGetterTask() {}
 197
 198 net::AuthCredentials MediaResourceGetterTask::RequestAuthCredentials(
 199     const GURL& url) const {
 200   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 201   net::HttpTransactionFactory* factory =
 202       context_getter_->GetURLRequestContext()->http_transaction_factory();
 203   if (!factory)
 204     return net::AuthCredentials();
 205
 206   net::HttpAuthCache* auth_cache =
 207       factory->GetSession()->http_auth_cache();
 208   if (!auth_cache)
 209     return net::AuthCredentials();
 210
 211   net::HttpAuthCache::Entry* entry =
 212       auth_cache->LookupByPath(url.GetOrigin(), url.path());
 213
 214   // TODO(qinmin): handle other auth schemes. See http://crbug.com/395219.
 215   if (entry && entry->scheme() == net::HttpAuth::AUTH_SCHEME_BASIC)
 216     return entry->credentials();
 217   else
 218     return net::AuthCredentials();
 219 }
 220
 221 void MediaResourceGetterTask::RequestCookies(
 222     const GURL& url, const GURL& first_party_for_cookies,
 223     const media::MediaResourceGetter::GetCookieCB& callback) {
 224   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 225   ChildProcessSecurityPolicyImpl* policy =
 226       ChildProcessSecurityPolicyImpl::GetInstance();
 227   if (!policy->CanAccessCookiesForOrigin(render_process_id_, url)) {
 228     callback.Run(std::string());
 229     return;
 230   }
 231
 232   net::CookieStore* cookie_store =
 233       context_getter_->GetURLRequestContext()->cookie_store();
 234   if (!cookie_store) {
 235     callback.Run(std::string());
 236     return;
 237   }
 238
 239   net::CookieMonster* cookie_monster = cookie_store->GetCookieMonster();
 240   if (cookie_monster) {
 241     cookie_monster->GetAllCookiesForURLAsync(url, base::Bind(
 242         &MediaResourceGetterTask::CheckPolicyForCookies, this,
 243         url, first_party_for_cookies, callback));
 244   } else {
 245     callback.Run(std::string());
 246   }
 247 }
 248
 249 void MediaResourceGetterTask::CheckPolicyForCookies(
 250     const GURL& url, const GURL& first_party_for_cookies,
 251     const media::MediaResourceGetter::GetCookieCB& callback,
 252     const net::CookieList& cookie_list) {
 253   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 254   if (GetContentClient()->browser()->AllowGetCookie(
 255       url, first_party_for_cookies, cookie_list,
 256       resource_context_, render_process_id_, render_frame_id_)) {
 257     net::CookieStore* cookie_store =
 258         context_getter_->GetURLRequestContext()->cookie_store();
 259     net::CookieOptions options;
 260     options.set_include_httponly();
 261     cookie_store->GetCookiesWithOptionsAsync(url, options, callback);
 262   } else {
 263     callback.Run(std::string());
 264   }
 265 }
 266
 267 MediaResourceGetterImpl::MediaResourceGetterImpl(
 268     BrowserContext* browser_context,
 269     storage::FileSystemContext* file_system_context,
 270     int render_process_id,
 271     int render_frame_id)
 272     : browser_context_(browser_context),
 273       file_system_context_(file_system_context),
 274       render_process_id_(render_process_id),
 275       render_frame_id_(render_frame_id),
 276       weak_factory_(this) {
 277 }
 278
 279 MediaResourceGetterImpl::~MediaResourceGetterImpl() {}
 280
 281 void MediaResourceGetterImpl::GetAuthCredentials(
 282     const GURL& url, const GetAuthCredentialsCB& callback) {
 283   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 284   scoped_refptr<MediaResourceGetterTask> task = new MediaResourceGetterTask(
 285       browser_context_, 0, 0);
 286
 287   BrowserThread::PostTaskAndReplyWithResult(
 288       BrowserThread::IO,
 289       FROM_HERE,
 290       base::Bind(&MediaResourceGetterTask::RequestAuthCredentials, task, url),
 291       base::Bind(&MediaResourceGetterImpl::GetAuthCredentialsCallback,
 292                  weak_factory_.GetWeakPtr(), callback));
 293 }
 294
 295 void MediaResourceGetterImpl::GetCookies(
 296     const GURL& url, const GURL& first_party_for_cookies,
 297     const GetCookieCB& callback) {
 298   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 299   scoped_refptr<MediaResourceGetterTask> task = new MediaResourceGetterTask(
 300       browser_context_, render_process_id_, render_frame_id_);
 301
 302   GetCookieCB cb = base::Bind(&MediaResourceGetterImpl::GetCookiesCallback,
 303                               weak_factory_.GetWeakPtr(),
 304                               callback);
 305   BrowserThread::PostTask(
 306       BrowserThread::IO,
 307       FROM_HERE,
 308       base::Bind(&MediaResourceGetterTask::RequestCookies,
 309                  task, url, first_party_for_cookies,
 310                  base::Bind(&ReturnResultOnUIThread, cb)));
 311 }
 312
 313 void MediaResourceGetterImpl::GetAuthCredentialsCallback(
 314     const GetAuthCredentialsCB& callback,
 315     const net::AuthCredentials& credentials) {
 316   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 317   callback.Run(credentials.username(), credentials.password());
 318 }
 319
 320 void MediaResourceGetterImpl::GetCookiesCallback(
 321     const GetCookieCB& callback, const std::string& cookies) {
 322   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 323   callback.Run(cookies);
 324 }
 325
 326 void MediaResourceGetterImpl::GetPlatformPathFromURL(
 327     const GURL& url, const GetPlatformPathCB& callback) {
 328   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 329   DCHECK(url.SchemeIsFileSystem() || url.SchemeIs(url::kBlobScheme));
 330
 331   GetPlatformPathCB cb =
 332       base::Bind(&MediaResourceGetterImpl::GetPlatformPathCallback,
 333                  weak_factory_.GetWeakPtr(),
 334                  callback);
 335
 336   if (url.SchemeIs(url::kBlobScheme)) {
 337     BrowserThread::PostTask(
 338         BrowserThread::IO,
 339         FROM_HERE,
 340         base::Bind(&RequestPlatformPathFromBlobURL, url,
 341                    browser_context_->GetResourceContext(), cb));
 342     return;
 343   }
 344
 345   scoped_refptr<storage::FileSystemContext> context(file_system_context_);
 346   BrowserThread::PostTask(
 347       BrowserThread::FILE,
 348       FROM_HERE,
 349       base::Bind(&RequestPlaformPathFromFileSystemURL, url, render_process_id_,
 350                  context, cb));
 351 }
 352
 353 void MediaResourceGetterImpl::GetPlatformPathCallback(
 354     const GetPlatformPathCB& callback, const std::string& platform_path) {
 355   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 356   callback.Run(platform_path);
 357 }
 358
 359 void MediaResourceGetterImpl::ExtractMediaMetadata(
 360     const std::string& url, const std::string& cookies,
 361     const std::string& user_agent, const ExtractMediaMetadataCB& callback) {
 362   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 363   base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool();
 364   pool->PostWorkerTask(
 365       FROM_HERE,
 366       base::Bind(&GetMediaMetadata, url, cookies, user_agent, callback));
 367 }
 368
 369 void MediaResourceGetterImpl::ExtractMediaMetadata(
 370     const int fd, const int64 offset, const int64 size,
 371     const ExtractMediaMetadataCB& callback) {
 372   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 373   base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool();
 374   pool->PostWorkerTask(
 375       FROM_HERE,
 376       base::Bind(&GetMediaMetadataFromFd, fd, offset, size, callback));
 377 }
 378
 379 // static
 380 bool MediaResourceGetterImpl::RegisterMediaResourceGetter(JNIEnv* env) {
 381   return RegisterNativesImpl(env);
 382 }
 383
 384 }  // namespace content