Support auto-reload on errors.

chrome/renderer/net/net_error_helper.cc

 // Copyright (c) 2013 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/renderer/net/net_error_helper.h"
 
 #include <string>
 
+#include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/localized_error.h"
 #include "chrome/common/net/net_error_info.h"
 #include "chrome/common/render_messages.h"
+#include "chrome/renderer/net/mockable_one_shot_timer.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/resource_fetcher.h"
 #include "grit/renderer_resources.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
@@ skipping 34 matching lines @@
   if (!frame->parent())
     return NetErrorHelperCore::MAIN_FRAME;
   return NetErrorHelperCore::SUB_FRAME;
 }
 
 }  // namespace
 
 NetErrorHelper::NetErrorHelper(RenderFrame* render_view)
     : RenderFrameObserver(render_view),
       content::RenderFrameObserverTracker<NetErrorHelper>(render_view),
-      core_(this) {
+      core_(this,
+            scoped_ptr<MockableOneShotTimer>(new MockableOneShotTimer())) {

[mmenke, 2014/03/11 20:07:54]

Optional:  I think it's a little cleaner to to remove MockableOneShotTimer from
this file, and have core create it itself.  Then add a set_timer_for_testing (Or
SetTimerForTesting) to core.

I think it's cleaner not to have this class know that detail of Core.  If you
think this is cleaner, or are paranoid about the timer being started on
construction, that's fine.

[Elly Fong-Jones, 2014/03/12 15:08:58]

Done.

+  RenderThread::Get()->AddObserver(this);
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  bool auto_reload_enabled =
+      command_line->HasSwitch(switches::kEnableOfflineAutoReload);
+  core_.set_auto_reload_enabled(auto_reload_enabled);
 }
 
 NetErrorHelper::~NetErrorHelper() {
+  RenderThread::Get()->RemoveObserver(this);
 }
 
 void NetErrorHelper::DidStartProvisionalLoad() {
   blink::WebFrame* frame = render_frame()->GetWebFrame();
   core_.OnStartLoad(GetFrameType(frame), GetLoadingPageType(frame));
 }
 
 void NetErrorHelper::DidCommitProvisionalLoad(bool is_new_navigation) {
   blink::WebFrame* frame = render_frame()->GetWebFrame();
   core_.OnCommitLoad(GetFrameType(frame));
@@ skipping 13 matching lines @@
 
   IPC_BEGIN_MESSAGE_MAP(NetErrorHelper, message)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_NetErrorInfo, OnNetErrorInfo)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetAltErrorPageURL, OnSetAltErrorPageURL);
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
+void NetErrorHelper::NetworkStateChanged(bool enabled) {
+  core_.NetworkStateChanged(enabled);
+}
+
 void NetErrorHelper::GetErrorHTML(
     blink::WebFrame* frame,
     const blink::WebURLError& error,
     bool is_failed_post,
     std::string* error_html) {
   core_.GetErrorHTML(GetFrameType(frame), error, is_failed_post, error_html);
 }
 
+bool NetErrorHelper::ShouldSuppressErrorPage(blink::WebFrame* frame,
+                                             const GURL& url) {
+  return core_.ShouldSuppressErrorPage(GetFrameType(frame), url);
+}
+
 void NetErrorHelper::GenerateLocalizedErrorPage(const blink::WebURLError& error,
                                                 bool is_failed_post,
                                                 std::string* error_html) const {
   error_html->clear();
 
   int resource_id = IDR_NET_ERROR_HTML;
   const base::StringPiece template_html(
       ResourceBundle::GetSharedInstance().GetRawDataResource(resource_id));
   if (template_html.empty()) {
     NOTREACHED() << "unable to load template.";
@@ skipping 64 matching lines @@
                      base::Unretained(this)));
 
   alt_error_page_fetcher_->SetTimeout(
       base::TimeDelta::FromSeconds(kAlterErrorPageFetchTimeoutSec));
 }
 
 void NetErrorHelper::CancelFetchErrorPage() {
   alt_error_page_fetcher_.reset();
 }
 
+void NetErrorHelper::ReloadPage() {
+  render_frame()->GetWebFrame()->reload(false);
+}
+
 void NetErrorHelper::OnNetErrorInfo(int status_num) {
   DCHECK(status_num >= 0 && status_num < chrome_common_net::DNS_PROBE_MAX);
 
   DVLOG(1) << "Received status " << DnsProbeStatusToString(status_num);
 
   core_.OnNetErrorInfo(static_cast<DnsProbeStatus>(status_num));
 }
 
 void NetErrorHelper::OnSetAltErrorPageURL(const GURL& alt_error_page_url) {
   core_.set_alt_error_page_url(alt_error_page_url);
 }
 
 void NetErrorHelper::OnAlternateErrorPageRetrieved(
     const blink::WebURLResponse& response,
     const std::string& data) {
   // The fetcher may only be deleted after |data| is passed to |core_|.  Move
   // it to a temporary to prevent any potential re-entrancy issues.
   scoped_ptr<content::ResourceFetcher> fetcher(
       alt_error_page_fetcher_.release());
   if (!response.isNull() && response.httpStatusCode() == 200) {
     core_.OnAlternateErrorPageFetched(data);
   } else {
     core_.OnAlternateErrorPageFetched("");
   }
 }