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