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

chrome/browser/net/net_error_tab_helper.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 "chrome/browser/net/net_error_tab_helper.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/net/dns_probe_service.h"
 #include "chrome/browser/net/net_error_diagnostics_dialog.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/localized_error.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "components/error_page/common/net_error_info.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/base/net_errors.h"
 #include "url/gurl.h"
 
 #if defined(OS_ANDROID)
@@ skipping 91 matching lines @@
     bool is_error_page,
     bool is_iframe_srcdoc) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (render_frame_host->GetParent())
     return;
 
   is_error_page_ = is_error_page;
 
 #if defined(OS_ANDROID)
-  SetHasOfflinePages(render_frame_host);
+  SetOfflinePageInfo(render_frame_host);
 #endif
 }
 
 void NetErrorTabHelper::DidCommitProvisionalLoadForFrame(
     content::RenderFrameHost* render_frame_host,
     const GURL& url,
     PageTransition transition_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (render_frame_host->GetParent())
@@ skipping 32 matching lines @@
 
 bool NetErrorTabHelper::OnMessageReceived(
     const IPC::Message& message,
     content::RenderFrameHost* render_frame_host) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(NetErrorTabHelper, message)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_RunNetworkDiagnostics,
                         RunNetworkDiagnostics)
 #if defined(OS_ANDROID)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_ShowOfflinePages, ShowOfflinePages)
+    IPC_MESSAGE_HANDLER(ChromeViewHostMsg_LoadOfflineCopy, LoadOfflineCopy)
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 NetErrorTabHelper::NetErrorTabHelper(WebContents* contents)
     : WebContentsObserver(contents),
       is_error_page_(false),
@@ skipping 89 matching lines @@
   // Sanitize URL prior to running diagnostics on it.
   RunNetworkDiagnosticsHelper(url.GetOrigin().spec());
 }
 
 void NetErrorTabHelper::RunNetworkDiagnosticsHelper(
     const std::string& sanitized_url) {
   ShowNetworkDiagnosticsDialog(web_contents(), sanitized_url);
 }
 
 #if defined(OS_ANDROID)
-void NetErrorTabHelper::SetHasOfflinePages(
+void NetErrorTabHelper::SetOfflinePageInfo(
   content::RenderFrameHost* render_frame_host) {
   DCHECK(web_contents());
+  OfflinePageStatus status = OfflinePageStatus::NONE;
   TabAndroid* tab = TabAndroid::FromWebContents(web_contents());
-  bool has_offline_pages = tab && tab->HasOfflinePages();
+  if (tab && tab->HasOfflinePages()) {
+    status = tab->HasOfflineCopyForCurrentPage() ?
+        OfflinePageStatus::HAS_PAGE_COPY : OfflinePageStatus::HAS_OTHER_COPIES;
+  }
   render_frame_host->Send(
-      new ChromeViewMsg_SetHasOfflinePages(
+      new ChromeViewMsg_SetOfflinePageInfo(
           render_frame_host->GetRoutingID(),
-          has_offline_pages));
+          static_cast<int>(status)));
 }
 
 void NetErrorTabHelper::ShowOfflinePages() {
   DCHECK(web_contents());
   TabAndroid* tab = TabAndroid::FromWebContents(web_contents());
   if (tab)
     tab->ShowOfflinePages();
 }
-#endif
+
+void NetErrorTabHelper::LoadOfflineCopy(const GURL& url) {

[nasko, 2015/11/13 23:55:13]

Since this URL comes from the renderer, it cannot be directly trusted. It needs
to be validated first. The pattern used is:

GURL validated_url(url);
if (validated_url.is_valid())
  // do whatever is correct for invalid URLs, here probably just return

Also, Daniel's comment still stands - doesn't this method allow for any page to
be requested? Is this intentional? What are the allowed pages to load?

[jianli, 2015/11/14 00:26:05]

Done.
No. Yes, currently only error page is allowed to trigger loading the offline
page.

[mmenke, 2015/11/14 00:41:11]

The renderer is untrusted.  Any page could claim to be an error page (And you're
not even checking that the URL came from an error page, actually).  Looks like
the TabAndroid code will only let bookmarked pages in the "offline page cache"
(For lack of a better term) to be shown, so any compromised renderer could
navigate to a bookmarked paged.  I guess this could leak the information about
whether or not a page is bookmarked, since if it's not, the navigation won't
occur.  I don't see any other security or privacy issues here?

A security engineer should still look at this (And you need an owner for
renderer_messages.h, anyways, conveniently enough)

[nasko, 2015/11/14 00:43:49]

When the renderer process is exploited by an attacker, it can lie that an error
page has been loaded in the process. How are we guarding against that?

[jianli, 2015/11/14 00:46:05]

Per my understanding, the button click handling in error page are done by
NetErrorPageController that is injected into v8. If we have problem with this,
all methods defined in NetErrorPageController face the same problem. 

+  DCHECK(web_contents());
+  TabAndroid* tab = TabAndroid::FromWebContents(web_contents());
+  if (tab)
+    tab->LoadOfflineCopy(url);
+}
+#endif  // defined(OS_ANDROID)
 
 }  // namespace chrome_browser_net