[New Tab Page] Change the mechanism to intercept online NTP errors

chrome/browser/ui/search/new_tab_page_interceptor_service.cc

+// Copyright 2015 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/ui/search/new_tab_page_interceptor_service.h"
+
+#include "base/location.h"
+#include "base/logging.h"
+#include "base/metrics/histogram.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/search/search.h"
+#include "chrome/browser/search_engines/template_url_service_factory.h"
+#include "chrome/common/url_constants.h"
+#include "components/search_engines/template_url_service.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/base/net_errors.h"
+#include "net/http/http_status_code.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_interceptor.h"
+#include "net/url_request/url_request_job.h"
+#include "net/url_request/url_request_redirect_job.h"
+#include "url/gurl.h"
+
+// Implementation of the URLRequestInterceptor for the New Tab Page. Will look
+// at incoming response from the server and possibly divert to the local NTP.
+class NewTabPageInterceptor : public net::URLRequestInterceptor {
+ public:
+  explicit NewTabPageInterceptor(const GURL& new_tab_url)
+      : new_tab_url_(new_tab_url), weak_factory_(this) {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  }
+
+  ~NewTabPageInterceptor() override {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  }
+
+  base::WeakPtr<NewTabPageInterceptor> GetWeakPtr() {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    return weak_factory_.GetWeakPtr();
+  }
+
+  void SetNewTabPageURL(const GURL& new_tab_page_url) {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+    new_tab_url_ = new_tab_page_url;
+  }
+
+ private:
+  // Overrides from net::URLRequestInterceptor:
+  net::URLRequestJob* MaybeInterceptRequest(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const override {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+    return nullptr;
+  }
+
+  net::URLRequestJob* MaybeInterceptResponse(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const override {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+    if ((request->url() != new_tab_url_) ||
+        (new_tab_url_ == GURL(chrome::kChromeSearchLocalNtpUrl))) {
+      return nullptr;
+    }
+    // User has canceled this navigation so it shouldn't be redirected.
+    if (request->status().status() == net::URLRequestStatus::CANCELED ||
+        (request->status().status() == net::URLRequestStatus::FAILED &&
+         request->status().error() == net::ERR_ABORTED)) {
+      return nullptr;
+    }
+
+    // Request to NTP was successful.
+    if (request->status().is_success() &&
+        request->GetResponseCode() != net::HTTP_NO_CONTENT &&
+        request->GetResponseCode() < 400) {
+      return nullptr;
+    }
+
+    // Failure to load the NTP correctly; redirect to Local NTP.
+    UMA_HISTOGRAM_ENUMERATION("InstantExtended.CacheableNTPLoad",
+                              chrome::CACHEABLE_NTP_LOAD_FAILED,
+                              chrome::CACHEABLE_NTP_LOAD_MAX);
+    return new net::URLRequestRedirectJob(
+        request, network_delegate, GURL(chrome::kChromeSearchLocalNtpUrl),
+        net::URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT,
+        "NTP Request Interceptor");
+  }
+
+  GURL new_tab_url_;
+  base::WeakPtrFactory<NewTabPageInterceptor> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(NewTabPageInterceptor);
+};
+
+NewTabPageInterceptorService::NewTabPageInterceptorService(Profile* profile)
+    : profile_(profile),
+      template_url_service_(TemplateURLServiceFactory::GetForProfile(profile)) {
+  DCHECK(profile_);
+  if (template_url_service_)
+    template_url_service_->AddObserver(this);
+}
+
+NewTabPageInterceptorService::~NewTabPageInterceptorService() {
+  if (template_url_service_)
+    template_url_service_->RemoveObserver(this);
+}
+
+void NewTabPageInterceptorService::OnTemplateURLServiceChanged() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  GURL new_tab_page_url(chrome::GetNewTabPageURL(profile_));
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&NewTabPageInterceptor::SetNewTabPageURL, interceptor_,
+                 new_tab_page_url));
+}
+
+scoped_ptr<net::URLRequestInterceptor>
+NewTabPageInterceptorService::CreateInterceptor() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  scoped_ptr<NewTabPageInterceptor> interceptor(
+      new NewTabPageInterceptor(chrome::GetNewTabPageURL(profile_)));
+  interceptor_ = interceptor->GetWeakPtr();
+  return interceptor.Pass();
+}