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"
@@ skipping 22 matching lines @@
 #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);
+  ScopedJavaLocalRef<jobject> jwindow_android =
+      view_core->GetWindowAndroid()->GetJavaObject();
+  if (HasFileAccessPermission(jwindow_android)) {
     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);
+      env, GetJavaObject()->Controller(env).obj(), jweb_contents.obj(),
+      jwindow_android.obj(), callback_id);
 }
 
 void DownloadControllerAndroidImpl::SetDefaultDownloadFileName(
     const std::string& file_name) {
   default_file_name_ = file_name;
 }
 
 bool DownloadControllerAndroidImpl::HasFileAccessPermission(
-    ScopedJavaLocalRef<jobject> j_content_view_core) {
+    ScopedJavaLocalRef<jobject> jwindow_android) {
   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.

[no sievers, 2016/05/27 19:09:25]

That would be really neat if we can get rid of this logic.

But if we can, then you can delete more code related to |deferred_downloads_| in
here and the whole DeferredDownLoadObserver class.

[Jinsuk Kim, 2016/05/30 01:20:57]

I don't think we need it any more once the dependency on ContentViewCore is
gone. I can see a TODO in DeferredDownloadObserver left by him about removing
the class. I'd like to hear what Min thinks about this.

-    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;
+  ScopedJavaLocalRef<jobject> jweb_contents = GetJavaWebContents(web_contents);
 
   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);
+      env, GetJavaObject()->Controller(env).obj(), jweb_contents.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);
 }
 
 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;
+  ScopedJavaLocalRef<jobject> jweb_contents =
+      GetJavaWebContents(download_item->GetWebContents());
 
   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());
+      env, GetJavaObject()->Controller(env).obj(), jweb_contents.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 55 matching lines @@
       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(
+  ScopedJavaLocalRef<jobject> jweb_contents = GetJavaWebContents(
       item->GetWebContents());
-  if (!view_core.is_null()) {
+  if (!jweb_contents.is_null()) {
     Java_DownloadController_onDangerousDownload(
-        env, GetJavaObject()->Controller(env).obj(), view_core.obj(),
+        env, GetJavaObject()->Controller(env).obj(), jweb_contents.obj(),
         jfilename.obj(), jguid.obj());
   }
 }
 
 ScopedJavaLocalRef<jobject>
     DownloadControllerAndroidImpl::GetContentViewCoreFromWebContents(
     WebContents* web_contents) {
   if (!web_contents)
     return ScopedJavaLocalRef<jobject>();
 
@@ skipping 67 matching lines @@
   if (info)
     has_user_gesture = info->HasUserGesture();
 }
 
 DownloadControllerAndroidImpl::DownloadInfoAndroid::DownloadInfoAndroid(
     const DownloadInfoAndroid& other) = default;
 
 DownloadControllerAndroidImpl::DownloadInfoAndroid::~DownloadInfoAndroid() {}
 
 }  // namespace content