Home | History | Annotate | Download | only in android 
      1 // Copyright (c) 2012 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/android/download_controller_android_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/logging.h"
     11 #include "base/memory/scoped_ptr.h"
     12 #include "base/time/time.h"
     13 #include "content/browser/android/content_view_core_impl.h"
     14 #include "content/browser/download/download_item_impl.h"
     15 #include "content/browser/download/download_manager_impl.h"
     16 #include "content/browser/loader/resource_dispatcher_host_impl.h"
     17 #include "content/browser/renderer_host/render_process_host_impl.h"
     18 #include "content/browser/renderer_host/render_view_host_delegate.h"
     19 #include "content/browser/renderer_host/render_view_host_impl.h"
     20 #include "content/browser/web_contents/web_contents_impl.h"
     21 #include "content/public/browser/browser_context.h"
     22 #include "content/public/browser/browser_thread.h"
     23 #include "content/public/browser/download_url_parameters.h"
     24 #include "content/public/browser/global_request_id.h"
     25 #include "content/public/common/referrer.h"
     26 #include "jni/DownloadController_jni.h"
     27 #include "net/cookies/cookie_options.h"
     28 #include "net/cookies/cookie_store.h"
     29 #include "net/http/http_content_disposition.h"
     30 #include "net/http/http_request_headers.h"
     31 #include "net/http/http_response_headers.h"
     32 #include "net/url_request/url_request.h"
     33 #include "net/url_request/url_request_context.h"
     34 
     35 using base::android::ConvertUTF8ToJavaString;
     36 using base::android::ScopedJavaLocalRef;
     37 
     38 namespace content {
     39 
     40 // JNI methods
     41 static void Init(JNIEnv* env, jobject obj) {
     42   DownloadControllerAndroidImpl::GetInstance()->Init(env, obj);
     43 }
     44 
     45 struct DownloadControllerAndroidImpl::JavaObject {
     46   ScopedJavaLocalRef<jobject> Controller(JNIEnv* env) {
     47     return GetRealObject(env, obj);
     48   }
     49   jweak obj;
     50 };
     51 
     52 // static
     53 bool DownloadControllerAndroidImpl::RegisterDownloadController(JNIEnv* env) {
     54   return RegisterNativesImpl(env);
     55 }
     56 
     57 // static
     58 DownloadControllerAndroid* DownloadControllerAndroid::Get() {
     59   return DownloadControllerAndroidImpl::GetInstance();
     60 }
     61 
     62 // static
     63 DownloadControllerAndroidImpl* DownloadControllerAndroidImpl::GetInstance() {
     64   return Singleton<DownloadControllerAndroidImpl>::get();
     65 }
     66 
     67 DownloadControllerAndroidImpl::DownloadControllerAndroidImpl()
     68     : java_object_(NULL) {
     69 }
     70 
     71 DownloadControllerAndroidImpl::~DownloadControllerAndroidImpl() {
     72   if (java_object_) {
     73     JNIEnv* env = base::android::AttachCurrentThread();
     74     env->DeleteWeakGlobalRef(java_object_->obj);
     75     delete java_object_;
     76     base::android::CheckException(env);
     77   }
     78 }
     79 
     80 // Initialize references to Java object.
     81 void DownloadControllerAndroidImpl::Init(JNIEnv* env, jobject obj) {
     82   java_object_ = new JavaObject;
     83   java_object_->obj = env->NewWeakGlobalRef(obj);
     84 }
     85 
     86 void DownloadControllerAndroidImpl::CreateGETDownload(
     87     int render_process_id, int render_view_id, int request_id) {
     88   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     89   GlobalRequestID global_id(render_process_id, request_id);
     90 
     91   // We are yielding the UI thread and render_view_host may go away by
     92   // the time we come back. Pass along render_process_id and render_view_id
     93   // to retrieve it later (if it still exists).
     94   GetDownloadInfoCB cb = base::Bind(
     95         &DownloadControllerAndroidImpl::StartAndroidDownload,
     96         base::Unretained(this), render_process_id,
     97         render_view_id);
     98 
     99   PrepareDownloadInfo(
    100       global_id,
    101       base::Bind(&DownloadControllerAndroidImpl::StartDownloadOnUIThread,
    102                  base::Unretained(this), cb));
    103 }
    104 
    105 void DownloadControllerAndroidImpl::PrepareDownloadInfo(
    106     const GlobalRequestID& global_id,
    107     const GetDownloadInfoCB& callback) {
    108   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    109 
    110   net::URLRequest* request =
    111       ResourceDispatcherHostImpl::Get()->GetURLRequest(global_id);
    112   if (!request) {
    113     LOG(ERROR) << "Request to download not found.";
    114     return;
    115   }
    116 
    117   DownloadInfoAndroid info_android(request);
    118 
    119   net::CookieStore* cookie_store = request->context()->cookie_store();
    120   if (cookie_store) {
    121     net::CookieMonster* cookie_monster = cookie_store->GetCookieMonster();
    122     if (cookie_monster) {
    123       cookie_monster->GetAllCookiesForURLAsync(
    124           request->url(),
    125           base::Bind(&DownloadControllerAndroidImpl::CheckPolicyAndLoadCookies,
    126                      base::Unretained(this), info_android, callback,
    127                      global_id));
    128     } else {
    129       DoLoadCookies(info_android, callback, global_id);
    130     }
    131   } else {
    132     // Can't get any cookies, start android download.
    133     callback.Run(info_android);
    134   }
    135 }
    136 
    137 void DownloadControllerAndroidImpl::CheckPolicyAndLoadCookies(
    138     const DownloadInfoAndroid& info, const GetDownloadInfoCB& callback,
    139     const GlobalRequestID& global_id, const net::CookieList& cookie_list) {
    140   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    141 
    142   net::URLRequest* request =
    143       ResourceDispatcherHostImpl::Get()->GetURLRequest(global_id);
    144   if (!request) {
    145     LOG(ERROR) << "Request to download not found.";
    146     return;
    147   }
    148 
    149   if (request->context()->network_delegate()->CanGetCookies(
    150       *request, cookie_list)) {
    151     DoLoadCookies(info, callback, global_id);
    152   } else {
    153     callback.Run(info);
    154   }
    155 }
    156 
    157 void DownloadControllerAndroidImpl::DoLoadCookies(
    158     const DownloadInfoAndroid& info, const GetDownloadInfoCB& callback,
    159     const GlobalRequestID& global_id) {
    160   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    161 
    162   net::CookieOptions options;
    163   options.set_include_httponly();
    164 
    165   net::URLRequest* request =
    166       ResourceDispatcherHostImpl::Get()->GetURLRequest(global_id);
    167   if (!request) {
    168     LOG(ERROR) << "Request to download not found.";
    169     return;
    170   }
    171 
    172   request->context()->cookie_store()->GetCookiesWithOptionsAsync(
    173       info.url, options,
    174       base::Bind(&DownloadControllerAndroidImpl::OnCookieResponse,
    175                  base::Unretained(this), info, callback));
    176 }
    177 
    178 void DownloadControllerAndroidImpl::OnCookieResponse(
    179     DownloadInfoAndroid download_info,
    180     const GetDownloadInfoCB& callback,
    181     const std::string& cookie) {
    182   download_info.cookie = cookie;
    183 
    184   // We have everything we need, start Android download.
    185   callback.Run(download_info);
    186 }
    187 
    188 void DownloadControllerAndroidImpl::StartDownloadOnUIThread(
    189     const GetDownloadInfoCB& callback,
    190     const DownloadInfoAndroid& info) {
    191   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    192   BrowserThread::PostTask(
    193       BrowserThread::UI, FROM_HERE, base::Bind(callback, info));
    194 }
    195 
    196 void DownloadControllerAndroidImpl::StartAndroidDownload(
    197     int render_process_id, int render_view_id,
    198     const DownloadInfoAndroid& info) {
    199   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    200   JNIEnv* env = base::android::AttachCurrentThread();
    201 
    202   // Call newHttpGetDownload
    203   ScopedJavaLocalRef<jobject> view = GetContentView(render_process_id,
    204                                                     render_view_id);
    205   if (view.is_null()) {
    206     // The view went away. Can't proceed.
    207     LOG(ERROR) << "Download failed on URL:" << info.url.spec();
    208     return;
    209   }
    210 
    211   ScopedJavaLocalRef<jstring> jurl =
    212       ConvertUTF8ToJavaString(env, info.url.spec());
    213   ScopedJavaLocalRef<jstring> juser_agent =
    214       ConvertUTF8ToJavaString(env, info.user_agent);
    215   ScopedJavaLocalRef<jstring> jcontent_disposition =
    216       ConvertUTF8ToJavaString(env, info.content_disposition);
    217   ScopedJavaLocalRef<jstring> jmime_type =
    218       ConvertUTF8ToJavaString(env, info.original_mime_type);
    219   ScopedJavaLocalRef<jstring> jcookie =
    220       ConvertUTF8ToJavaString(env, info.cookie);
    221   ScopedJavaLocalRef<jstring> jreferer =
    222       ConvertUTF8ToJavaString(env, info.referer);
    223 
    224   // Try parsing the content disposition header to get a
    225   // explicitly specified filename if available.
    226   net::HttpContentDisposition header(info.content_disposition, "");
    227   ScopedJavaLocalRef<jstring> jfilename =
    228       ConvertUTF8ToJavaString(env, header.filename());
    229 
    230   Java_DownloadController_newHttpGetDownload(
    231       env, GetJavaObject()->Controller(env).obj(), view.obj(), jurl.obj(),
    232       juser_agent.obj(), jcontent_disposition.obj(), jmime_type.obj(),
    233       jcookie.obj(), jreferer.obj(), jfilename.obj(), info.total_bytes);
    234 }
    235 
    236 void DownloadControllerAndroidImpl::OnDownloadStarted(
    237     DownloadItem* download_item) {
    238   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    239   if (!download_item->GetWebContents())
    240     return;
    241 
    242   JNIEnv* env = base::android::AttachCurrentThread();
    243 
    244   // Register for updates to the DownloadItem.
    245   download_item->AddObserver(this);
    246 
    247   ScopedJavaLocalRef<jobject> view =
    248       GetContentViewCoreFromWebContents(download_item->GetWebContents());
    249   // The view went away. Can't proceed.
    250   if (view.is_null())
    251     return;
    252 
    253   ScopedJavaLocalRef<jstring> jmime_type =
    254       ConvertUTF8ToJavaString(env, download_item->GetMimeType());
    255   ScopedJavaLocalRef<jstring> jfilename = ConvertUTF8ToJavaString(
    256       env, download_item->GetTargetFilePath().BaseName().value());
    257   Java_DownloadController_onDownloadStarted(
    258       env, GetJavaObject()->Controller(env).obj(), view.obj(), jfilename.obj(),
    259       jmime_type.obj());
    260 }
    261 
    262 void DownloadControllerAndroidImpl::OnDownloadUpdated(DownloadItem* item) {
    263   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    264   if (item->IsDangerous() && (item->GetState() != DownloadItem::CANCELLED))
    265     OnDangerousDownload(item);
    266 
    267   JNIEnv* env = base::android::AttachCurrentThread();
    268   ScopedJavaLocalRef<jstring> jurl =
    269       ConvertUTF8ToJavaString(env, item->GetURL().spec());
    270   ScopedJavaLocalRef<jstring> jmime_type =
    271       ConvertUTF8ToJavaString(env, item->GetMimeType());
    272   ScopedJavaLocalRef<jstring> jpath =
    273       ConvertUTF8ToJavaString(env, item->GetTargetFilePath().value());
    274   ScopedJavaLocalRef<jstring> jfilename = ConvertUTF8ToJavaString(
    275       env, item->GetTargetFilePath().BaseName().value());
    276 
    277   switch (item->GetState()) {
    278     case DownloadItem::IN_PROGRESS: {
    279       base::TimeDelta time_delta;
    280       item->TimeRemaining(&time_delta);
    281       Java_DownloadController_onDownloadUpdated(
    282           env, GetJavaObject()->Controller(env).obj(),
    283           base::android::GetApplicationContext(), jurl.obj(), jmime_type.obj(),
    284           jfilename.obj(), jpath.obj(), item->GetReceivedBytes(), true,
    285           item->GetId(), item->PercentComplete(), time_delta.InMilliseconds());
    286       break;
    287     }
    288     case DownloadItem::COMPLETE:
    289       // Multiple OnDownloadUpdated() notifications may be issued while the
    290       // download is in the COMPLETE state. Only handle one.
    291       item->RemoveObserver(this);
    292 
    293       // Call onDownloadCompleted
    294       Java_DownloadController_onDownloadCompleted(
    295           env, GetJavaObject()->Controller(env).obj(),
    296           base::android::GetApplicationContext(), jurl.obj(), jmime_type.obj(),
    297           jfilename.obj(), jpath.obj(), item->GetReceivedBytes(), true,
    298           item->GetId());
    299       break;
    300     case DownloadItem::CANCELLED:
    301     // TODO(shashishekhar): An interrupted download can be resumed. Android
    302     // currently does not support resumable downloads. Add handling for
    303     // interrupted case based on item->CanResume().
    304     case DownloadItem::INTERRUPTED:
    305       // Call onDownloadCompleted with success = false.
    306       Java_DownloadController_onDownloadCompleted(
    307           env, GetJavaObject()->Controller(env).obj(),
    308           base::android::GetApplicationContext(), jurl.obj(), jmime_type.obj(),
    309           jfilename.obj(), jpath.obj(), item->GetReceivedBytes(), false,
    310           item->GetId());
    311       break;
    312     case DownloadItem::MAX_DOWNLOAD_STATE:
    313       NOTREACHED();
    314   }
    315 }
    316 
    317 void DownloadControllerAndroidImpl::OnDangerousDownload(DownloadItem* item) {
    318   JNIEnv* env = base::android::AttachCurrentThread();
    319   ScopedJavaLocalRef<jstring> jfilename = ConvertUTF8ToJavaString(
    320       env, item->GetTargetFilePath().BaseName().value());
    321   ScopedJavaLocalRef<jobject> view_core = GetContentViewCoreFromWebContents(
    322       item->GetWebContents());
    323   if (!view_core.is_null()) {
    324     Java_DownloadController_onDangerousDownload(
    325         env, GetJavaObject()->Controller(env).obj(), view_core.obj(),
    326         jfilename.obj(), item->GetId());
    327   }
    328 }
    329 
    330 ScopedJavaLocalRef<jobject> DownloadControllerAndroidImpl::GetContentView(
    331     int render_process_id, int render_view_id) {
    332   RenderViewHost* render_view_host =
    333       RenderViewHost::FromID(render_process_id, render_view_id);
    334 
    335   if (!render_view_host)
    336     return ScopedJavaLocalRef<jobject>();
    337 
    338   WebContents* web_contents =
    339       render_view_host->GetDelegate()->GetAsWebContents();
    340 
    341   return GetContentViewCoreFromWebContents(web_contents);
    342 }
    343 
    344 ScopedJavaLocalRef<jobject>
    345     DownloadControllerAndroidImpl::GetContentViewCoreFromWebContents(
    346     WebContents* web_contents) {
    347   if (!web_contents)
    348     return ScopedJavaLocalRef<jobject>();
    349 
    350   ContentViewCore* view_core = ContentViewCore::FromWebContents(web_contents);
    351   return view_core ? view_core->GetJavaObject() :
    352       ScopedJavaLocalRef<jobject>();
    353 }
    354 
    355 DownloadControllerAndroidImpl::JavaObject*
    356     DownloadControllerAndroidImpl::GetJavaObject() {
    357   if (!java_object_) {
    358     // Initialize Java DownloadController by calling
    359     // DownloadController.getInstance(), which will call Init()
    360     // if Java DownloadController is not instantiated already.
    361     JNIEnv* env = base::android::AttachCurrentThread();
    362     Java_DownloadController_getInstance(env);
    363   }
    364 
    365   DCHECK(java_object_);
    366   return java_object_;
    367 }
    368 
    369 void DownloadControllerAndroidImpl::StartContextMenuDownload(
    370     const ContextMenuParams& params, WebContents* web_contents, bool is_link) {
    371   const GURL& url = is_link ? params.link_url : params.src_url;
    372   const GURL& referrer = params.frame_url.is_empty() ?
    373       params.page_url : params.frame_url;
    374   DownloadManagerImpl* dlm = static_cast<DownloadManagerImpl*>(
    375       BrowserContext::GetDownloadManager(web_contents->GetBrowserContext()));
    376   scoped_ptr<DownloadUrlParameters> dl_params(
    377       DownloadUrlParameters::FromWebContents(web_contents, url));
    378   dl_params->set_referrer(
    379       Referrer(referrer, params.referrer_policy));
    380   if (is_link)
    381     dl_params->set_referrer_encoding(params.frame_charset);
    382   else
    383     dl_params->set_prefer_cache(true);
    384   dl_params->set_prompt(false);
    385   dlm->DownloadUrl(dl_params.Pass());
    386 }
    387 
    388 void DownloadControllerAndroidImpl::DangerousDownloadValidated(
    389     WebContents* web_contents, int download_id, bool accept) {
    390   if (!web_contents)
    391     return;
    392   DownloadManagerImpl* dlm = static_cast<DownloadManagerImpl*>(
    393       BrowserContext::GetDownloadManager(web_contents->GetBrowserContext()));
    394   DownloadItem* item = dlm->GetDownload(download_id);
    395   if (!item)
    396     return;
    397   if (accept)
    398     item->ValidateDangerousDownload();
    399   else
    400     item->Remove();
    401 }
    402 
    403 DownloadControllerAndroidImpl::DownloadInfoAndroid::DownloadInfoAndroid(
    404     net::URLRequest* request) {
    405   request->GetResponseHeaderByName("content-disposition", &content_disposition);
    406 
    407   if (request->response_headers())
    408     request->response_headers()->GetMimeType(&original_mime_type);
    409 
    410   request->extra_request_headers().GetHeader(
    411       net::HttpRequestHeaders::kUserAgent, &user_agent);
    412   GURL referer_url(request->referrer());
    413   if (referer_url.is_valid())
    414     referer = referer_url.spec();
    415   if (!request->url_chain().empty()) {
    416     original_url = request->url_chain().front();
    417     url = request->url_chain().back();
    418   }
    419 }
    420 
    421 DownloadControllerAndroidImpl::DownloadInfoAndroid::~DownloadInfoAndroid() {}
    422 
    423 }  // namespace content
    424