Move DownloadControllerAndroid from content/ to chrome/

content/browser/android/download_controller_android_impl.cc

 // Copyright (c) 2012 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/android/download_controller_android_impl.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/android/context_utils.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "content/browser/android/content_view_core_impl.h"
 #include "content/browser/android/deferred_download_observer.h"
 #include "content/browser/download/download_item_impl.h"
 #include "content/browser/download/download_manager_impl.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/browser/web_contents/web_contents_android.h"
 #include "content/browser/web_contents/web_contents_impl.h"
+#include "content/public/browser/android/download_delegate.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_url_parameters.h"
 #include "content/public/browser/global_request_id.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/referrer.h"
 #include "jni/DownloadController_jni.h"
 #include "net/base/filename_util.h"
 #include "net/cookies/cookie_options.h"
 #include "net/cookies/cookie_store.h"
 #include "net/http/http_content_disposition.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
+#include "ui/android/window_android.h"
 
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ScopedJavaLocalRef;
 
 namespace {
 // Guards download_controller_
 base::LazyInstance<base::Lock> g_download_controller_lock_;
 
 content::WebContents* GetWebContents(int render_process_id,
                                      int render_view_id) {
   content::RenderViewHost* render_view_host =
       content::RenderViewHost::FromID(render_process_id, render_view_id);
 
   if (!render_view_host)
     return nullptr;
 
   return content::WebContents::FromRenderViewHost(render_view_host);
 }
 
+ScopedJavaLocalRef<jobject>
+GetJavaWebContents(content::WebContents* web_contents) {
+  return (static_cast<content::WebContentsImpl*>(web_contents))
+      ->GetJavaWebContents();
+}
+
 void CreateContextMenuDownload(int render_process_id,
                                int render_view_id,
                                const content::ContextMenuParams& params,
                                bool is_link,
                                const std::string& extra_headers,
                                bool granted) {
   if (!granted)
     return;
 
   content::WebContents* web_contents =
@@ skipping 124 matching lines @@
     }
   }
 }
 
 void DownloadControllerAndroidImpl::AcquireFileAccessPermission(
     WebContents* web_contents,
     const DownloadControllerAndroid::AcquireFileAccessPermissionCallback& cb) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(web_contents);
 
-  ScopedJavaLocalRef<jobject> view =
-      GetContentViewCoreFromWebContents(web_contents);
-  if (view.is_null()) {
+  ContentViewCore* view_core = ContentViewCore::FromWebContents(web_contents);
+  if (!view_core) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, base::Bind(cb, false));
     return;
   }
 
-  if (HasFileAccessPermission(view)) {
+  ScopedJavaLocalRef<jobject> jweb_contents =
+      GetJavaWebContents(web_contents);
+  if (HasFileAccessPermission(view_core->GetWindowAndroid())) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, base::Bind(cb, true));
     return;
   }
-
-  JNIEnv* env = base::android::AttachCurrentThread();
   // Make copy on the heap so we can pass the pointer through JNI.
   intptr_t callback_id = reinterpret_cast<intptr_t>(
       new DownloadControllerAndroid::AcquireFileAccessPermissionCallback(cb));
-  Java_DownloadController_requestFileAccess(
-      env, GetJavaObject()->Controller(env).obj(), view.obj(), callback_id);
+  content::WebContentsImpl* web_contents_impl =
+      static_cast<content::WebContentsImpl*>(web_contents);
+  web_contents_impl->GetWebContentsAndroid()->GetDownloadDelegate()->
+      RequestFileAccess(callback_id);
 }
 
 void DownloadControllerAndroidImpl::SetDefaultDownloadFileName(
     const std::string& file_name) {
   default_file_name_ = file_name;
 }
 
 bool DownloadControllerAndroidImpl::HasFileAccessPermission(
-    ScopedJavaLocalRef<jobject> j_content_view_core) {
+    ui::WindowAndroid* window_android) {
+  ScopedJavaLocalRef<jobject> jwindow_android = window_android->GetJavaObject();
+
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK(!j_content_view_core.is_null());
+  DCHECK(!jwindow_android.is_null());
 
   JNIEnv* env = base::android::AttachCurrentThread();
   return Java_DownloadController_hasFileAccess(
-      env, GetJavaObject()->Controller(env).obj(), j_content_view_core.obj());
+      env, GetJavaObject()->Controller(env).obj(), jwindow_android.obj());
 }
 
 void DownloadControllerAndroidImpl::CreateGETDownload(
     int render_process_id, int render_view_id, int request_id,
     bool must_download) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   GlobalRequestID global_id(render_process_id, request_id);
 
   // We are yielding the UI thread and render_view_host may go away by
   // the time we come back. Pass along render_process_id and render_view_id
@@ skipping 98 matching lines @@
     int render_process_id, int render_view_id, bool must_download,
     const DownloadInfoAndroid& info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   WebContents* web_contents = GetWebContents(render_process_id, render_view_id);
   if (!web_contents) {
     // The view went away. Can't proceed.
     LOG(ERROR) << "Download failed on URL:" << info.url.spec();
     return;
   }
-  ScopedJavaLocalRef<jobject> view =
-      GetContentViewCoreFromWebContents(web_contents);
-  if (view.is_null()) {
-    // ContentViewCore might not have been created yet, pass a callback to
-    // DeferredDownloadTaskManager so that the download can restart when
-    // ContentViewCore is created.
-    deferred_downloads_.push_back(new DeferredDownloadObserver(
-        web_contents,
-        base::Bind(&DownloadControllerAndroidImpl::StartAndroidDownload,
-                   base::Unretained(this), render_process_id, render_view_id,
-                   must_download, info)));
-    return;
-  }
 
   AcquireFileAccessPermission(
       web_contents,
       base::Bind(&DownloadControllerAndroidImpl::StartAndroidDownloadInternal,
                  base::Unretained(this), render_process_id, render_view_id,
                  must_download, info));
 }
 
 void DownloadControllerAndroidImpl::StartAndroidDownloadInternal(
     int render_process_id, int render_view_id, bool must_download,
     const DownloadInfoAndroid& info, bool allowed) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!allowed)
     return;
 
   // Call newHttpGetDownload
   WebContents* web_contents = GetWebContents(render_process_id, render_view_id);
   // The view went away. Can't proceed.
   if (!web_contents)
     return;
-  ScopedJavaLocalRef<jobject> view =
-      GetContentViewCoreFromWebContents(web_contents);
-  if (view.is_null())
-    return;
 
-  JNIEnv* env = base::android::AttachCurrentThread();
-  ScopedJavaLocalRef<jstring> jurl =
-      ConvertUTF8ToJavaString(env, info.url.spec());
-  ScopedJavaLocalRef<jstring> juser_agent =
-      ConvertUTF8ToJavaString(env, info.user_agent);
-  ScopedJavaLocalRef<jstring> jcontent_disposition =
-      ConvertUTF8ToJavaString(env, info.content_disposition);
-  ScopedJavaLocalRef<jstring> jmime_type =
-      ConvertUTF8ToJavaString(env, info.original_mime_type);
-  ScopedJavaLocalRef<jstring> jcookie =
-      ConvertUTF8ToJavaString(env, info.cookie);
-  ScopedJavaLocalRef<jstring> jreferer =
-      ConvertUTF8ToJavaString(env, info.referer);
-
-  // net::GetSuggestedFilename will fallback to "download" as filename.
-  ScopedJavaLocalRef<jstring> jfilename =
-      base::android::ConvertUTF16ToJavaString(
-          env, net::GetSuggestedFilename(info.url, info.content_disposition,
-                                         std::string(),  // referrer_charset
-                                         std::string(),  // suggested_name
-                                         info.original_mime_type,
-                                         default_file_name_));
-
-  Java_DownloadController_newHttpGetDownload(
-      env, GetJavaObject()->Controller(env).obj(), view.obj(), jurl.obj(),
-      juser_agent.obj(), jcontent_disposition.obj(), jmime_type.obj(),
-      jcookie.obj(), jreferer.obj(), info.has_user_gesture, jfilename.obj(),
-      info.total_bytes, must_download);
+  content::WebContentsImpl* web_contents_impl =
+      (static_cast<content::WebContentsImpl*>(web_contents));
+  base::string16 filename = net::GetSuggestedFilename(
+      info.url, info.content_disposition,
+      std::string(),  // referrer_charset
+      std::string(),  // suggested_name
+      info.original_mime_type,
+      default_file_name_);
+  web_contents_impl->GetWebContentsAndroid()->GetDownloadDelegate()->
+      NewHTTPGetDownload(info.url.spec(), info.user_agent,
+                         info.content_disposition, info.original_mime_type,
+                         info.cookie, info.referer, filename,
+                         info.total_bytes, info.has_user_gesture,
+                         must_download);
 }
 
 void DownloadControllerAndroidImpl::OnDownloadStarted(
     DownloadItem* download_item) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!download_item->GetWebContents())
     return;
 
-  JNIEnv* env = base::android::AttachCurrentThread();
-
   // Register for updates to the DownloadItem.
   download_item->AddObserver(this);
 
-  ScopedJavaLocalRef<jobject> view =
-      GetContentViewCoreFromWebContents(download_item->GetWebContents());
-  // The view went away. Can't proceed.
-  if (view.is_null())
-    return;
+  content::WebContentsImpl* web_contents_impl =
+      (static_cast<content::WebContentsImpl*>(download_item->GetWebContents()));
+  web_contents_impl->GetWebContentsAndroid()->GetDownloadDelegate()->
+      OnDownloadStarted(download_item->GetTargetFilePath().BaseName().value(),
+                        download_item->GetMimeType());
 
-  ScopedJavaLocalRef<jstring> jmime_type =
-      ConvertUTF8ToJavaString(env, download_item->GetMimeType());
-  ScopedJavaLocalRef<jstring> jfilename = ConvertUTF8ToJavaString(
-      env, download_item->GetTargetFilePath().BaseName().value());
-  Java_DownloadController_onDownloadStarted(
-      env, GetJavaObject()->Controller(env).obj(), view.obj(), jfilename.obj(),
-      jmime_type.obj());
 }
 
 void DownloadControllerAndroidImpl::OnDownloadUpdated(DownloadItem* item) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (item->IsDangerous() && (item->GetState() != DownloadItem::CANCELLED))
     OnDangerousDownload(item);
 
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jstring> jguid =
       ConvertUTF8ToJavaString(env, item->GetGuid());
@@ skipping 50 matching lines @@
           item->CanResume(), IsInterruptedDownloadAutoResumable(item),
           item->GetBrowserContext()->IsOffTheRecord());
       item->RemoveObserver(this);
       break;
     case DownloadItem::MAX_DOWNLOAD_STATE:
       NOTREACHED();
   }
 }
 
 void DownloadControllerAndroidImpl::OnDangerousDownload(DownloadItem* item) {
-  JNIEnv* env = base::android::AttachCurrentThread();
-  ScopedJavaLocalRef<jstring> jfilename = ConvertUTF8ToJavaString(
-      env, item->GetTargetFilePath().BaseName().value());
-  ScopedJavaLocalRef<jstring> jguid =
-      ConvertUTF8ToJavaString(env, item->GetGuid());
-  ScopedJavaLocalRef<jobject> view_core = GetContentViewCoreFromWebContents(
-      item->GetWebContents());
-  if (!view_core.is_null()) {
-    Java_DownloadController_onDangerousDownload(
-        env, GetJavaObject()->Controller(env).obj(), view_core.obj(),
-        jfilename.obj(), jguid.obj());
-  }
+  content::WebContentsImpl* web_contents_impl =
+      (static_cast<content::WebContentsImpl*>(item->GetWebContents()));
+  web_contents_impl->GetWebContentsAndroid()->GetDownloadDelegate()->
+      OnDownloadStarted(item->GetTargetFilePath().BaseName().value(),
+                        item->GetGuid());
 }
 
 ScopedJavaLocalRef<jobject>
     DownloadControllerAndroidImpl::GetContentViewCoreFromWebContents(
     WebContents* web_contents) {
   if (!web_contents)
     return ScopedJavaLocalRef<jobject>();
 
   ContentViewCore* view_core = ContentViewCore::FromWebContents(web_contents);
   return view_core ? view_core->GetJavaObject() :
@@ skipping 65 matching lines @@
   if (info)
     has_user_gesture = info->HasUserGesture();
 }
 
 DownloadControllerAndroidImpl::DownloadInfoAndroid::DownloadInfoAndroid(
     const DownloadInfoAndroid& other) = default;
 
 DownloadControllerAndroidImpl::DownloadInfoAndroid::~DownloadInfoAndroid() {}
 
 }  // namespace content