chrome/browser/android/offline_pages/offline_page_bridge.cc

   1 // Copyright 2015 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 "chrome/browser/android/offline_pages/offline_page_bridge.h"
   6
   7 #include "base/android/jni_string.h"
   8 #include "base/files/file_path.h"
   9 #include "chrome/browser/android/offline_pages/offline_page_mhtml_archiver.h"
  10 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
  11 #include "chrome/browser/download/download_prefs.h"
  12 #include "chrome/browser/profiles/profile.h"
  13 #include "chrome/browser/profiles/profile_android.h"
  14 #include "components/offline_pages/offline_page_feature.h"
  15 #include "components/offline_pages/offline_page_item.h"
  16 #include "components/offline_pages/offline_page_model.h"
  17 #include "content/public/browser/browser_context.h"
  18 #include "content/public/browser/download_manager.h"
  19 #include "content/public/browser/web_contents.h"
  20 #include "jni/OfflinePageBridge_jni.h"
  21
  22 using base::android::ConvertJavaStringToUTF8;
  23 using base::android::ConvertUTF16ToJavaString;
  24 using base::android::ConvertUTF8ToJavaString;
  25 using base::android::ScopedJavaGlobalRef;
  26
  27 namespace offline_pages {
  28 namespace android {
  29
  30 namespace {
  31
  32 void LoadAllPagesCallback(ScopedJavaGlobalRef<jobject>* j_callback_obj,
  33                           ScopedJavaGlobalRef<jobject>* j_result_obj,
  34                           OfflinePageModel::LoadResult result,
  35                           const std::vector<OfflinePageItem>& offline_pages) {
  36   JNIEnv* env = base::android::AttachCurrentThread();
  37
  38   scoped_ptr<ScopedJavaGlobalRef<jobject>> j_callback_ptr(j_callback_obj);
  39   scoped_ptr<ScopedJavaGlobalRef<jobject>> j_result_ptr(j_result_obj);
  40
  41   for (const OfflinePageItem& offline_page : offline_pages) {
  42     Java_OfflinePageBridge_createOfflinePageAndAddToList(
  43         env, j_result_ptr->obj(),
  44         ConvertUTF8ToJavaString(env, offline_page.url.spec()).obj(),
  45         offline_page.bookmark_id,
  46         ConvertUTF8ToJavaString(env, offline_page.GetOfflineURL().spec()).obj(),
  47         offline_page.file_size);
  48   }
  49
  50   Java_OfflinePageCallback_onLoadAllPagesDone(env, j_callback_ptr->obj(),
  51                                               static_cast<int>(result),
  52                                               j_result_ptr->obj());
  53 }
  54
  55 void SavePageCallback(ScopedJavaGlobalRef<jobject>* j_callback_obj,
  56                       const GURL& url,
  57                       OfflinePageModel::SavePageResult result) {
  58   JNIEnv* env = base::android::AttachCurrentThread();
  59
  60   scoped_ptr<ScopedJavaGlobalRef<jobject>> j_callback_ptr(j_callback_obj);
  61
  62   Java_OfflinePageCallback_onSavePageDone(
  63       env, j_callback_ptr->obj(), static_cast<int>(result),
  64       ConvertUTF8ToJavaString(env, url.spec()).obj());
  65 }
  66
  67 }  // namespace
  68
  69 static jboolean IsOfflinePagesEnabled(JNIEnv* env, jclass clazz) {
  70   return offline_pages::IsOfflinePagesEnabled();
  71 }
  72
  73 OfflinePageBridge::OfflinePageBridge(JNIEnv* env,
  74                                      jobject obj,
  75                                      content::BrowserContext* browser_context)
  76     : weak_java_ref_(env, obj),
  77       offline_page_model_(OfflinePageModelFactory::GetForBrowserContext(
  78           browser_context)),
  79       browser_context_(browser_context) {
  80 }
  81
  82 void OfflinePageBridge::Destroy(JNIEnv*, jobject) {
  83   delete this;
  84 }
  85
  86 void OfflinePageBridge::LoadAllPages(JNIEnv* env,
  87                                      jobject obj,
  88                                      jobject j_callback_obj,
  89                                      jobject j_result_obj) {
  90   DCHECK(j_callback_obj);
  91   DCHECK(j_result_obj);
  92
  93   scoped_ptr<ScopedJavaGlobalRef<jobject>> j_callback_obj_ptr(
  94       new ScopedJavaGlobalRef<jobject>());
  95   j_callback_obj_ptr->Reset(env, j_callback_obj);
  96
  97   scoped_ptr<ScopedJavaGlobalRef<jobject>> j_result_obj_ptr(
  98       new ScopedJavaGlobalRef<jobject>());
  99   j_result_obj_ptr->Reset(env, j_result_obj);
 100
 101   offline_page_model_->LoadAllPages(base::Bind(&LoadAllPagesCallback,
 102                                                j_callback_obj_ptr.release(),
 103                                                j_result_obj_ptr.release()));
 104 }
 105
 106 void OfflinePageBridge::SavePage(JNIEnv* env,
 107                                  jobject obj,
 108                                  jobject j_callback_obj,
 109                                  jobject j_web_contents,
 110                                  jlong bookmark_id) {
 111   DCHECK(j_callback_obj);
 112   DCHECK(j_web_contents);
 113
 114   scoped_ptr<ScopedJavaGlobalRef<jobject>> j_callback_obj_ptr(
 115       new ScopedJavaGlobalRef<jobject>());
 116   j_callback_obj_ptr->Reset(env, j_callback_obj);
 117
 118   content::WebContents* web_contents =
 119       content::WebContents::FromJavaWebContents(j_web_contents);
 120   GURL url(web_contents->GetLastCommittedURL());
 121
 122   scoped_ptr<OfflinePageArchiver> archiver(
 123       new OfflinePageMHTMLArchiver(web_contents, GetDownloadsPath()));
 124
 125   offline_page_model_->SavePage(
 126       url, bookmark_id, archiver.Pass(),
 127       base::Bind(&SavePageCallback, j_callback_obj_ptr.release(), url));
 128 }
 129
 130 base::FilePath OfflinePageBridge::GetDownloadsPath() const {
 131   content::DownloadManager* manager =
 132       content::BrowserContext::GetDownloadManager(browser_context_);
 133   if (!manager) {
 134     DVLOG(1) << "No download manager available in offline page bridge";
 135     return base::FilePath();
 136   }
 137
 138   return DownloadPrefs::FromDownloadManager(manager)->DownloadPath();
 139 }
 140
 141 static jlong Init(JNIEnv* env, jobject obj, jobject j_profile) {
 142   return reinterpret_cast<jlong>(new OfflinePageBridge(
 143       env, obj, ProfileAndroid::FromProfileAndroid(j_profile)));
 144 }
 145
 146 bool RegisterOfflinePageBridge(JNIEnv* env) {
 147   return RegisterNativesImpl(env);
 148 }
 149
 150 }  // namespace android
 151 }  // namespace offline_pages