Add "Show saved copy" button in dino page when there's offline copy

chrome/browser/android/tab_android.cc

 // Copyright 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 "chrome/browser/android/tab_android.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/metrics/histogram.h"
@@ skipping 269 matching lines @@
 
   // Only allows the browser-initiated navigation to use POST.
   if (params->uses_post && !params->is_renderer_initiated) {
     load_url_params->load_type =
         NavigationController::LOAD_TYPE_BROWSER_INITIATED_HTTP_POST;
     load_url_params->browser_initiated_post_data =
         params->browser_initiated_post_data;
   }
 }
 
 bool TabAndroid::HasOfflinePages() const {

[newt (away), 2015/11/13 19:20:19]

All the methods related to offline pages should be grouped together. And the
order of the methods in the .cc and .h file should be the same.

Longer term, I'd like to see the offline page functionality moved into a
separate class, e.g. an OfflinePageTabHelper or something like that.

[jianli, 2015/11/13 22:32:13]

Done.
Will do. Added the workitem into our tracking list.

    if (!offline_pages::IsOfflinePagesEnabled())
     return false;
   offline_pages::OfflinePageModel* offline_page_model =
       offline_pages::OfflinePageModelFactory::GetForBrowserContext(
           GetProfile());
   return !offline_page_model->GetAllPages().empty();
 }
 
 void TabAndroid::ShowOfflinePages() {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_Tab_showOfflinePages(env, weak_java_tab_.get(env).obj());
 }
 
+void TabAndroid::LoadOfflineCopy(const GURL& url) {
+  if (!offline_pages::IsOfflinePagesEnabled())
+    return;
+
+  // Offline copy is only saved for a bookmarked page.
+  int64_t bookmark_id = GetBookmarkIdHelper(true);
+  if (bookmark_id == -1)
+    return;
+
+  offline_pages::OfflinePageModel* offline_page_model =
+      offline_pages::OfflinePageModelFactory::GetForBrowserContext(
+          GetProfile());
+  if (!offline_page_model)
+    return;
+  const offline_pages::OfflinePageItem* offline_page =
+      offline_page_model->GetPageByBookmarkId(bookmark_id);
+  if (!offline_page)
+    return;
+  GURL offline_url = offline_page->GetOfflineURL();
+  if (!offline_url.is_valid())
+    return;
+
+  content::NavigationController::LoadURLParams load_params(offline_url);
+  web_contents()->GetController().LoadURLWithParams(load_params);
+}
+
 void TabAndroid::SwapTabContents(content::WebContents* old_contents,
                                  content::WebContents* new_contents,
                                  bool did_start_load,
                                  bool did_finish_load) {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_Tab_swapWebContents(
       env,
       weak_java_tab_.get(env).obj(),
       new_contents->GetJavaWebContents().obj(),
       did_start_load,
@@ skipping 448 matching lines @@
 void TabAndroid::LoadOriginalImage(JNIEnv* env, jobject obj) {
   content::RenderFrameHost* render_frame_host =
       web_contents()->GetFocusedFrame();
   render_frame_host->Send(new ChromeViewMsg_RequestReloadImageForContextNode(
       render_frame_host->GetRoutingID()));
 }
 
 jlong TabAndroid::GetBookmarkId(JNIEnv* env,
                                jobject obj,
                                jboolean only_editable) {
+  return GetBookmarkIdHelper(only_editable);
+}
+
+int64_t TabAndroid::GetBookmarkIdHelper(bool only_editable) const {
   GURL url = dom_distiller::url_utils::GetOriginalUrlFromDistillerUrl(
       web_contents()->GetURL());
   Profile* profile = GetProfile();
 
   // If the url points to an offline page, replace it with the original url.
   const offline_pages::OfflinePageItem* offline_page = GetOfflinePage(url);
   if (offline_page)
     url = offline_page->url;
 
   // Get all the nodes for |url| and sort them by date added.
   std::vector<const bookmarks::BookmarkNode*> nodes;
   bookmarks::ManagedBookmarkService* managed =
       ManagedBookmarkServiceFactory::GetForProfile(profile);
   bookmarks::BookmarkModel* model =
       BookmarkModelFactory::GetForProfile(profile);
   model->GetNodesByURL(url, &nodes);
   std::sort(nodes.begin(), nodes.end(), &bookmarks::MoreRecentlyAdded);
 
   // Return the first node matching the search criteria.
   for (size_t i = 0; i < nodes.size(); ++i) {
     if (only_editable && !managed->CanBeEditedByUser(nodes[i]))
       continue;
     return nodes[i]->id();
   }
 
   return -1;
 }
 
 jboolean TabAndroid::HasOfflineCopy(JNIEnv* env, jobject obj) {
+  return HasOfflineCopyForCurrentPage();
+}
+
+bool TabAndroid::HasOfflineCopyForCurrentPage() const {
   // Offline copy is only saved for a bookmarked page.
-  jlong bookmark_id = GetBookmarkId(env, obj, true);
+  int64_t bookmark_id = GetBookmarkIdHelper(true);
   if (bookmark_id == -1)
     return false;
 
   offline_pages::OfflinePageModel* offline_page_model =
       offline_pages::OfflinePageModelFactory::GetForBrowserContext(
           GetProfile());
   if (!offline_page_model)
     return false;
   const offline_pages::OfflinePageItem* offline_page =
       offline_page_model->GetPageByBookmarkId(bookmark_id);
@@ skipping 110 matching lines @@
 static void Init(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   TRACE_EVENT0("native", "TabAndroid::Init");
   // This will automatically bind to the Java object and pass ownership there.
   new TabAndroid(env, obj);
 }
 
 // static
 bool TabAndroid::RegisterTabAndroid(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }