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/browser/web_contents_view.h"
     26 #include "content/public/common/referrer.h"
     27 #include "jni/DownloadController_jni.h"
     28 #include "net/cookies/cookie_options.h"
     29 #include "net/cookies/cookie_store.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   Java_DownloadController_newHttpGetDownload(
    225       env, GetJavaObject()->Controller(env).obj(), view.obj(), jurl.obj(),
    226       juser_agent.obj(), jcontent_disposition.obj(), jmime_type.obj(),
    227       jcookie.obj(), jreferer.obj(), info.total_bytes);
    228 }
    229 
    230 void DownloadControllerAndroidImpl::OnDownloadStarted(
    231     DownloadItem* download_item) {
    232   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    233   if (!download_item->GetWebContents())
    234     return;
    235 
    236   JNIEnv* env = base::android::AttachCurrentThread();
    237 
    238   // Register for updates to the DownloadItem.
    239   download_item->AddObserver(this);
    240 
    241   ScopedJavaLocalRef<jobject> view =
    242       GetContentViewCoreFromWebContents(download_item->GetWebContents());
    243   // The view went away. Can't proceed.
    244   if (view.is_null())
    245     return;
    246 
    247   ScopedJavaLocalRef<jstring> jmime_type =
    248       ConvertUTF8ToJavaString(env, download_item->GetMimeType());
    249   ScopedJavaLocalRef<jstring> jfilename = ConvertUTF8ToJavaString(
    250       env, download_item->GetTargetFilePath().BaseName().value());
    251   Java_DownloadController_onDownloadStarted(
    252       env, GetJavaObject()->Controller(env).obj(), view.obj(), jfilename.obj(),
    253       jmime_type.obj());
    254 }
    255 
    256 void DownloadControllerAndroidImpl::OnDownloadUpdated(DownloadItem* item) {
    257   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    258   if (item->IsDangerous() && (item->GetState() != DownloadItem::CANCELLED))
    259     OnDangerousDownload(item);
    260 
    261   JNIEnv* env = base::android::AttachCurrentThread();
    262   ScopedJavaLocalRef<jstring> jurl =
    263       ConvertUTF8ToJavaString(env, item->GetURL().spec());
    264   ScopedJavaLocalRef<jstring> jmime_type =
    265       ConvertUTF8ToJavaString(env, item->GetMimeType());
    266   ScopedJavaLocalRef<jstring> jpath =
    267       ConvertUTF8ToJavaString(env, item->GetTargetFilePath().value());
    268   ScopedJavaLocalRef<jstring> jfilename = ConvertUTF8ToJavaString(
    269       env, item->GetTargetFilePath().BaseName().value());
    270 
    271   switch (item->GetState()) {
    272     case DownloadItem::IN_PROGRESS: {
    273       base::TimeDelta time_delta;
    274       item->TimeRemaining(&time_delta);
    275       Java_DownloadController_onDownloadUpdated(
    276           env, GetJavaObject()->Controller(env).obj(),
    277           base::android::GetApplicationContext(), jurl.obj(), jmime_type.obj(),
    278           jfilename.obj(), jpath.obj(), item->GetReceivedBytes(), true,
    279           item->GetId(), item->PercentComplete(), time_delta.InMilliseconds());
    280       break;
    281     }
    282     case DownloadItem::COMPLETE:
    283       // Multiple OnDownloadUpdated() notifications may be issued while the
    284       // download is in the COMPLETE state. Only handle one.
    285       item->RemoveObserver(this);
    286 
    287       // Call onDownloadCompleted
    288       Java_DownloadController_onDownloadCompleted(
    289           env, GetJavaObject()->Controller(env).obj(),
    290           base::android::GetApplicationContext(), jurl.obj(), jmime_type.obj(),
    291           jfilename.obj(), jpath.obj(), item->GetReceivedBytes(), true,
    292           item->GetId());
    293       break;
    294     case DownloadItem::CANCELLED:
    295     // TODO(shashishekhar): An interrupted download can be resumed. Android
    296     // currently does not support resumable downloads. Add handling for
    297     // interrupted case based on item->CanResume().
    298     case DownloadItem::INTERRUPTED:
    299       // Call onDownloadCompleted with success = false.
    300       Java_DownloadController_onDownloadCompleted(
    301           env, GetJavaObject()->Controller(env).obj(),
    302           base::android::GetApplicationContext(), jurl.obj(), jmime_type.obj(),
    303           jfilename.obj(), jpath.obj(), item->GetReceivedBytes(), false,
    304           item->GetId());
    305       break;
    306     case DownloadItem::MAX_DOWNLOAD_STATE:
    307       NOTREACHED();
    308   }
    309 }
    310 
    311 void DownloadControllerAndroidImpl::OnDangerousDownload(DownloadItem* item) {
    312   JNIEnv* env = base::android::AttachCurrentThread();
    313   ScopedJavaLocalRef<jstring> jfilename = ConvertUTF8ToJavaString(
    314       env, item->GetTargetFilePath().BaseName().value());
    315   ScopedJavaLocalRef<jobject> view_core = GetContentViewCoreFromWebContents(
    316       item->GetWebContents());
    317   if (!view_core.is_null()) {
    318     Java_DownloadController_onDangerousDownload(
    319         env, GetJavaObject()->Controller(env).obj(), view_core.obj(),
    320         jfilename.obj(), item->GetId());
    321   }
    322 }
    323 
    324 ScopedJavaLocalRef<jobject> DownloadControllerAndroidImpl::GetContentView(
    325     int render_process_id, int render_view_id) {
    326   RenderViewHost* render_view_host =
    327       RenderViewHost::FromID(render_process_id, render_view_id);
    328 
    329   if (!render_view_host)
    330     return ScopedJavaLocalRef<jobject>();
    331 
    332   WebContents* web_contents =
    333       render_view_host->GetDelegate()->GetAsWebContents();
    334 
    335   return GetContentViewCoreFromWebContents(web_contents);
    336 }
    337 
    338 ScopedJavaLocalRef<jobject>
    339     DownloadControllerAndroidImpl::GetContentViewCoreFromWebContents(
    340     WebContents* web_contents) {
    341   if (!web_contents)
    342     return ScopedJavaLocalRef<jobject>();
    343 
    344   ContentViewCore* view_core = ContentViewCore::FromWebContents(web_contents);
    345   return view_core ? view_core->GetJavaObject() :
    346       ScopedJavaLocalRef<jobject>();
    347 }
    348 
    349 DownloadControllerAndroidImpl::JavaObject*
    350     DownloadControllerAndroidImpl::GetJavaObject() {
    351   if (!java_object_) {
    352     // Initialize Java DownloadController by calling
    353     // DownloadController.getInstance(), which will call Init()
    354     // if Java DownloadController is not instantiated already.
    355     JNIEnv* env = base::android::AttachCurrentThread();
    356     Java_DownloadController_getInstance(env);
    357   }
    358 
    359   DCHECK(java_object_);
    360   return java_object_;
    361 }
    362 
    363 void DownloadControllerAndroidImpl::StartContextMenuDownload(
    364     const ContextMenuParams& params, WebContents* web_contents, bool is_link) {
    365   const GURL& url = is_link ? params.link_url : params.src_url;
    366   const GURL& referrer = params.frame_url.is_empty() ?
    367       params.page_url : params.frame_url;
    368   DownloadManagerImpl* dlm = static_cast<DownloadManagerImpl*>(
    369       BrowserContext::GetDownloadManager(web_contents->GetBrowserContext()));
    370   scoped_ptr<DownloadUrlParameters> dl_params(
    371       DownloadUrlParameters::FromWebContents(web_contents, url));
    372   dl_params->set_referrer(
    373       Referrer(referrer, params.referrer_policy));
    374   if (is_link)
    375     dl_params->set_referrer_encoding(params.frame_charset);
    376   else
    377     dl_params->set_prefer_cache(true);
    378   dl_params->set_prompt(false);
    379   dlm->DownloadUrl(dl_params.Pass());
    380 }
    381 
    382 void DownloadControllerAndroidImpl::DangerousDownloadValidated(
    383     WebContents* web_contents, int download_id, bool accept) {
    384   if (!web_contents)
    385     return;
    386   DownloadManagerImpl* dlm = static_cast<DownloadManagerImpl*>(
    387       BrowserContext::GetDownloadManager(web_contents->GetBrowserContext()));
    388   DownloadItem* item = dlm->GetDownload(download_id);
    389   if (!item)
    390     return;
    391   if (accept)
    392     item->ValidateDangerousDownload();
    393   else
    394     item->Remove();
    395 }
    396 
    397 DownloadControllerAndroidImpl::DownloadInfoAndroid::DownloadInfoAndroid(
    398     net::URLRequest* request) {
    399   request->GetResponseHeaderByName("content-disposition", &content_disposition);
    400 
    401   if (request->response_headers())
    402     request->response_headers()->GetMimeType(&original_mime_type);
    403 
    404   request->extra_request_headers().GetHeader(
    405       net::HttpRequestHeaders::kUserAgent, &user_agent);
    406   GURL referer_url(request->referrer());
    407   if (referer_url.is_valid())
    408     referer = referer_url.spec();
    409   if (!request->url_chain().empty()) {
    410     original_url = request->url_chain().front();
    411     url = request->url_chain().back();
    412   }
    413 }
    414 
    415 DownloadControllerAndroidImpl::DownloadInfoAndroid::~DownloadInfoAndroid() {}
    416 
    417 }  // namespace content
    418