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_array.h"
   8 #include "base/android/jni_string.h"
   9 #include "base/basictypes.h"
  10 #include "base/files/file_path.h"
  11 #include "base/strings/string_util.h"
  12 #include "chrome/browser/android/offline_pages/offline_page_mhtml_archiver.h"
  13 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
  14 #include "chrome/browser/download/download_prefs.h"
  15 #include "chrome/browser/profiles/profile.h"
  16 #include "chrome/browser/profiles/profile_android.h"
  17 #include "components/offline_pages/offline_page_feature.h"
  18 #include "components/offline_pages/offline_page_item.h"
  19 #include "components/offline_pages/offline_page_model.h"
  20 #include "content/public/browser/browser_context.h"
  21 #include "content/public/browser/download_manager.h"
  22 #include "content/public/browser/web_contents.h"
  23 #include "jni/OfflinePageBridge_jni.h"
  24 #include "net/base/filename_util.h"
  25
  26 using base::android::ConvertJavaStringToUTF8;
  27 using base::android::ConvertUTF16ToJavaString;
  28 using base::android::ConvertUTF8ToJavaString;
  29 using base::android::ScopedJavaGlobalRef;
  30 using base::android::ScopedJavaLocalRef;
  31
  32 namespace offline_pages {
  33 namespace android {
  34
  35 namespace {
  36
  37 void SavePageCallback(const ScopedJavaGlobalRef<jobject>& j_callback_obj,
  38                       const GURL& url,
  39                       OfflinePageModel::SavePageResult result) {
  40   JNIEnv* env = base::android::AttachCurrentThread();
  41
  42   Java_SavePageCallback_onSavePageDone(
  43       env, j_callback_obj.obj(), static_cast<int>(result),
  44       ConvertUTF8ToJavaString(env, url.spec()).obj());
  45 }
  46
  47 void DeletePageCallback(const ScopedJavaGlobalRef<jobject>& j_callback_obj,
  48                         OfflinePageModel::DeletePageResult result) {
  49   JNIEnv* env = base::android::AttachCurrentThread();
  50
  51   Java_DeletePageCallback_onDeletePageDone(
  52       env, j_callback_obj.obj(), static_cast<int>(result));
  53 }
  54
  55 void ToJavaOfflinePageList(JNIEnv* env,
  56                            jobject j_result_obj,
  57                            const std::vector<OfflinePageItem>& offline_pages) {
  58   for (const OfflinePageItem& offline_page : offline_pages) {
  59     Java_OfflinePageBridge_createOfflinePageAndAddToList(
  60         env, j_result_obj,
  61         ConvertUTF8ToJavaString(env, offline_page.url.spec()).obj(),
  62         offline_page.bookmark_id,
  63         ConvertUTF8ToJavaString(env, offline_page.GetOfflineURL().spec()).obj(),
  64         offline_page.file_size);
  65   }
  66 }
  67
  68 }  // namespace
  69
  70 static jboolean IsOfflinePagesEnabled(JNIEnv* env,
  71                                       const JavaParamRef<jclass>& clazz) {
  72   return offline_pages::IsOfflinePagesEnabled();
  73 }
  74
  75 OfflinePageBridge::OfflinePageBridge(JNIEnv* env,
  76                                      jobject obj,
  77                                      content::BrowserContext* browser_context)
  78     : weak_java_ref_(env, obj),
  79       offline_page_model_(OfflinePageModelFactory::GetForBrowserContext(
  80           browser_context)),
  81       browser_context_(browser_context) {
  82   NotifyIfDoneLoading();
  83   offline_page_model_->AddObserver(this);
  84 }
  85
  86 void OfflinePageBridge::Destroy(JNIEnv*, jobject) {
  87   offline_page_model_->RemoveObserver(this);
  88   delete this;
  89 }
  90
  91 void OfflinePageBridge::OfflinePageModelLoaded(OfflinePageModel* model) {
  92   DCHECK_EQ(offline_page_model_, model);
  93   NotifyIfDoneLoading();
  94 }
  95
  96 void OfflinePageBridge::GetAllPages(JNIEnv* env,
  97                                     jobject obj,
  98                                     jobject j_result_obj) {
  99   DCHECK(offline_page_model_->is_loaded());
 100   DCHECK(j_result_obj);
 101   const std::vector<OfflinePageItem>& offline_pages =
 102       offline_page_model_->GetAllPages();
 103   ToJavaOfflinePageList(env, j_result_obj, offline_pages);
 104 }
 105
 106 void OfflinePageBridge::GetPagesToCleanUp(JNIEnv* env,
 107                                           jobject obj,
 108                                           jobject j_result_obj) {
 109   DCHECK(offline_page_model_->is_loaded());
 110   DCHECK(j_result_obj);
 111   const std::vector<OfflinePageItem>& offline_pages =
 112       offline_page_model_->GetPagesToCleanUp();
 113   ToJavaOfflinePageList(env, j_result_obj, offline_pages);
 114 }
 115
 116 ScopedJavaLocalRef<jobject> OfflinePageBridge::GetPageByBookmarkId(
 117     JNIEnv* env,
 118     jobject obj,
 119     jlong bookmark_id) {
 120   OfflinePageItem offline_page;
 121   if (!offline_page_model_->GetPageByBookmarkId(bookmark_id, &offline_page))
 122     return ScopedJavaLocalRef<jobject>();
 123
 124   return Java_OfflinePageBridge_createOfflinePageItem(
 125       env, ConvertUTF8ToJavaString(env, offline_page.url.spec()).obj(),
 126       offline_page.bookmark_id,
 127       ConvertUTF8ToJavaString(env, offline_page.GetOfflineURL().spec()).obj(),
 128       offline_page.file_size);
 129 }
 130
 131 void OfflinePageBridge::SavePage(JNIEnv* env,
 132                                  jobject obj,
 133                                  jobject j_callback_obj,
 134                                  jobject j_web_contents,
 135                                  jlong bookmark_id) {
 136   DCHECK(j_callback_obj);
 137   DCHECK(j_web_contents);
 138
 139   ScopedJavaGlobalRef<jobject> j_callback_ref;
 140   j_callback_ref.Reset(env, j_callback_obj);
 141
 142   content::WebContents* web_contents =
 143       content::WebContents::FromJavaWebContents(j_web_contents);
 144   GURL url(web_contents->GetLastCommittedURL());
 145
 146   scoped_ptr<OfflinePageArchiver> archiver(
 147       new OfflinePageMHTMLArchiver(
 148           web_contents, GetDownloadsPath(browser_context_)));
 149
 150   offline_page_model_->SavePage(
 151       url, bookmark_id, archiver.Pass(),
 152       base::Bind(&SavePageCallback, j_callback_ref, url));
 153 }
 154
 155 void OfflinePageBridge::DeletePage(JNIEnv* env,
 156                                    jobject obj,
 157                                    jobject j_callback_obj,
 158                                    jlong bookmark_id) {
 159   DCHECK(j_callback_obj);
 160
 161   ScopedJavaGlobalRef<jobject> j_callback_ref;
 162   j_callback_ref.Reset(env, j_callback_obj);
 163
 164   offline_page_model_->DeletePageByBookmarkId(bookmark_id, base::Bind(
 165       &DeletePageCallback, j_callback_ref));
 166 }
 167
 168 void OfflinePageBridge::DeletePages(JNIEnv* env,
 169                                     jobject obj,
 170                                     jobject j_callback_obj,
 171                                     jlongArray bookmark_ids_array) {
 172   DCHECK(j_callback_obj);
 173
 174   ScopedJavaGlobalRef<jobject> j_callback_ref;
 175   j_callback_ref.Reset(env, j_callback_obj);
 176
 177   std::vector<int64> bookmark_ids;
 178   base::android::JavaLongArrayToInt64Vector(env, bookmark_ids_array,
 179                                             &bookmark_ids);
 180
 181   offline_page_model_->DeletePagesByBookmarkId(
 182       bookmark_ids,
 183       base::Bind(&DeletePageCallback, j_callback_ref));
 184 }
 185
 186 void OfflinePageBridge::NotifyIfDoneLoading() const {
 187   if (!offline_page_model_->is_loaded())
 188     return;
 189   JNIEnv* env = base::android::AttachCurrentThread();
 190   ScopedJavaLocalRef<jobject> obj = weak_java_ref_.get(env);
 191   if (obj.is_null())
 192     return;
 193   Java_OfflinePageBridge_offlinePageModelLoaded(env, obj.obj());
 194 }
 195
 196 // static
 197 bool OfflinePageBridge::MightBeOfflineURL(const GURL& url) {
 198   // It has to be a file URL ending with .mhtml extension.
 199   return url.is_valid() &&
 200          url.SchemeIsFile() &&
 201          base::EndsWith(url.spec(),
 202                         OfflinePageMHTMLArchiver::GetFileNameExtension(),
 203                         base::CompareCase::INSENSITIVE_ASCII);
 204 }
 205
 206 // static
 207 base::FilePath OfflinePageBridge::GetDownloadsPath(
 208     content::BrowserContext* browser_context) {
 209   content::DownloadManager* manager =
 210       content::BrowserContext::GetDownloadManager(browser_context);
 211   if (!manager) {
 212     DVLOG(1) << "No download manager available in offline page bridge";
 213     return base::FilePath();
 214   }
 215
 216   return DownloadPrefs::FromDownloadManager(manager)->DownloadPath();
 217 }
 218
 219 static jlong Init(JNIEnv* env,
 220                   const JavaParamRef<jobject>& obj,
 221                   const JavaParamRef<jobject>& j_profile) {
 222   return reinterpret_cast<jlong>(new OfflinePageBridge(
 223       env, obj, ProfileAndroid::FromProfileAndroid(j_profile)));
 224 }
 225
 226 bool RegisterOfflinePageBridge(JNIEnv* env) {
 227   return RegisterNativesImpl(env);
 228 }
 229
 230 }  // namespace android
 231 }  // namespace offline_pages