Support basic authentication for html5 media

content/browser/media/android/media_resource_getter_impl.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 "content/browser/media/android/media_resource_getter_impl.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/path_service.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/fileapi/browser_file_system_helper.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/url_constants.h"
 #include "jni/MediaResourceGetter_jni.h"
+#include "net/base/auth.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_store.h"
+#include "net/http/http_auth.h"
+#include "net/http/http_transaction_factory.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "url/gurl.h"
 #include "webkit/browser/blob/blob_data_handle.h"
 #include "webkit/browser/blob/blob_storage_context.h"
 
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ScopedJavaLocalRef;
 
 namespace content {
@@ skipping 64 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(callback, base::TimeDelta::FromMilliseconds(
                      Java_MediaMetadata_getDurationInMilliseconds(
                          env, j_metadata.obj())),
                  Java_MediaMetadata_getWidth(env, j_metadata.obj()),
                  Java_MediaMetadata_getHeight(env, j_metadata.obj()),
                  Java_MediaMetadata_isSuccess(env, j_metadata.obj())));
 }
 
-// The task object that retrieves cookie on the IO thread.
+// The task object that retrieves media resources on the IO thread.
 // TODO(qinmin): refactor this class to make the code reusable by others as
 // there are lots of duplicated functionalities elsewhere.
-class CookieGetterTask
-     : public base::RefCountedThreadSafe<CookieGetterTask> {
+// http://crbug.com/395762.
+class MediaResourceGetterTask
+     : public base::RefCountedThreadSafe<MediaResourceGetterTask> {
  public:
-  CookieGetterTask(BrowserContext* browser_context,
-                   int render_process_id, int render_frame_id);
+  MediaResourceGetterTask(BrowserContext* browser_context,
+                          int render_process_id, int render_frame_id);
 
-  // Called by CookieGetterImpl to start getting cookies for a URL.
+  // Called by MediaResourceGetterImpl to start getting auth credentials.
+  net::AuthCredentials RequestAuthCredentials(const GURL& url) const;
+
+  // Called by MediaResourceGetterImpl to start getting cookies for a URL.
   void RequestCookies(
       const GURL& url, const GURL& first_party_for_cookies,
       const media::MediaResourceGetter::GetCookieCB& callback);
 
  private:
-  friend class base::RefCountedThreadSafe<CookieGetterTask>;
-  virtual ~CookieGetterTask();
+  friend class base::RefCountedThreadSafe<MediaResourceGetterTask>;
+  virtual ~MediaResourceGetterTask();
 
   void CheckPolicyForCookies(
       const GURL& url, const GURL& first_party_for_cookies,
       const media::MediaResourceGetter::GetCookieCB& callback,
       const net::CookieList& cookie_list);
 
-  // Context getter used to get the CookieStore.
+  // Context getter used to get the CookieStore and auth cache.
   net::URLRequestContextGetter* context_getter_;
 
   // Resource context for checking cookie policies.
   ResourceContext* resource_context_;
 
   // Render process id, used to check whether the process can access cookies.
   int render_process_id_;
 
   // Render frame id, used to check tab specific cookie policy.
   int render_frame_id_;
 
-  DISALLOW_COPY_AND_ASSIGN(CookieGetterTask);
+  DISALLOW_COPY_AND_ASSIGN(MediaResourceGetterTask);
 };
 
-CookieGetterTask::CookieGetterTask(
+MediaResourceGetterTask::MediaResourceGetterTask(
     BrowserContext* browser_context, int render_process_id, int render_frame_id)
     : context_getter_(browser_context->GetRequestContext()),
       resource_context_(browser_context->GetResourceContext()),
       render_process_id_(render_process_id),
       render_frame_id_(render_frame_id) {
 }
 
-CookieGetterTask::~CookieGetterTask() {}
+MediaResourceGetterTask::~MediaResourceGetterTask() {}
 
-void CookieGetterTask::RequestCookies(
+net::AuthCredentials MediaResourceGetterTask::RequestAuthCredentials(
+    const GURL& url) const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  net::HttpTransactionFactory* factory =
+      context_getter_->GetURLRequestContext()->http_transaction_factory();
+  if (!factory)
+    return net::AuthCredentials();
+
+  net::HttpAuthCache* auth_cache =
+      factory->GetSession()->http_auth_cache();
+  if (!auth_cache)
+    return net::AuthCredentials();
+
+  net::HttpAuthCache::Entry* entry =
+      auth_cache->LookupByPath(url.GetOrigin(), url.path());
+
+  // TODO(qinmin): handle other auth schemes. See http://crbug.com/395219.
+  if (entry && entry->scheme() == net::HttpAuth::AUTH_SCHEME_BASIC)
+    return entry->credentials();
+  else
+    return net::AuthCredentials();
+}
+
+void MediaResourceGetterTask::RequestCookies(
     const GURL& url, const GURL& first_party_for_cookies,
     const media::MediaResourceGetter::GetCookieCB& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ChildProcessSecurityPolicyImpl* policy =
       ChildProcessSecurityPolicyImpl::GetInstance();
   if (!policy->CanAccessCookiesForOrigin(render_process_id_, url)) {
     callback.Run(std::string());
     return;
   }
 
   net::CookieStore* cookie_store =
       context_getter_->GetURLRequestContext()->cookie_store();
   if (!cookie_store) {
     callback.Run(std::string());
     return;
   }
 
   net::CookieMonster* cookie_monster = cookie_store->GetCookieMonster();
   if (cookie_monster) {
     cookie_monster->GetAllCookiesForURLAsync(url, base::Bind(
-        &CookieGetterTask::CheckPolicyForCookies, this,
+        &MediaResourceGetterTask::CheckPolicyForCookies, this,
         url, first_party_for_cookies, callback));
   } else {
     callback.Run(std::string());
   }
 }
 
-void CookieGetterTask::CheckPolicyForCookies(
+void MediaResourceGetterTask::CheckPolicyForCookies(
     const GURL& url, const GURL& first_party_for_cookies,
     const media::MediaResourceGetter::GetCookieCB& callback,
     const net::CookieList& cookie_list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (GetContentClient()->browser()->AllowGetCookie(
       url, first_party_for_cookies, cookie_list,
       resource_context_, render_process_id_, render_frame_id_)) {
     net::CookieStore* cookie_store =
         context_getter_->GetURLRequestContext()->cookie_store();
     net::CookieOptions options;
@@ skipping 10 matching lines @@
     int render_process_id,
     int render_frame_id)
     : browser_context_(browser_context),
       file_system_context_(file_system_context),
       render_process_id_(render_process_id),
       render_frame_id_(render_frame_id),
       weak_factory_(this) {}
 
 MediaResourceGetterImpl::~MediaResourceGetterImpl() {}
 
+void MediaResourceGetterImpl::GetAuthCredentials(
+    const GURL& url, const GetAuthCredentialsCB& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  scoped_refptr<MediaResourceGetterTask> task = new MediaResourceGetterTask(
+      browser_context_, 0, 0);
+
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&MediaResourceGetterTask::RequestAuthCredentials, task, url),
+      base::Bind(&MediaResourceGetterImpl::GetAuthCredentialsCallback,
+                 weak_factory_.GetWeakPtr(), callback));
+}
+
 void MediaResourceGetterImpl::GetCookies(
     const GURL& url, const GURL& first_party_for_cookies,
     const GetCookieCB& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  scoped_refptr<CookieGetterTask> task = new CookieGetterTask(
+  scoped_refptr<MediaResourceGetterTask> task = new MediaResourceGetterTask(
       browser_context_, render_process_id_, render_frame_id_);
 
   GetCookieCB cb = base::Bind(&MediaResourceGetterImpl::GetCookiesCallback,
                               weak_factory_.GetWeakPtr(),
                               callback);
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&CookieGetterTask::RequestCookies,
+      base::Bind(&MediaResourceGetterTask::RequestCookies,
                  task, url, first_party_for_cookies,
                  base::Bind(&ReturnResultOnUIThread, cb)));
 }
 
+void MediaResourceGetterImpl::GetAuthCredentialsCallback(
+    const GetAuthCredentialsCB& callback,
+    const net::AuthCredentials& credentials) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  callback.Run(credentials.username(), credentials.password());
+}
+
 void MediaResourceGetterImpl::GetCookiesCallback(
     const GetCookieCB& callback, const std::string& cookies) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   callback.Run(cookies);
 }
 
 void MediaResourceGetterImpl::GetPlatformPathFromURL(
     const GURL& url, const GetPlatformPathCB& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(url.SchemeIsFileSystem() || url.SchemeIs(url::kBlobScheme));
@@ skipping 34 matching lines @@
       FROM_HERE,
       base::Bind(&GetMediaMetadata, url, cookies, user_agent, callback));
 }
 
 // static
 bool MediaResourceGetterImpl::RegisterMediaResourceGetter(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace content