Add a chrome://interstitials page.

Screenshots:
https://docs.google.com/file/d/0B9q2eN9gDoUIUUhrMlpydVNTVXc/edit?pli=1
https://drive.google.com/file/d/0B9q2eN9gDoUIMjdhQ1p3M05zNDQ/edit?usp=sharing

BUG=389749

Review URL: https://codereview.chromium.org/368143002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@285766 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 392 insertions, 19 deletions

diff --git a/chrome/browser/chrome_content_browser_client.cc b/chrome/browser/chrome_content_browser_client.cc
index bdf325c..7b02bef 100644
--- a/chrome/browser/chrome_content_browser_client.cc
+++ b/chrome/browser/chrome_content_browser_client.cc
@@ -2019,8 +2019,8 @@ void ChromeContentBrowserClient::AllowCertificateError(
 #endif
 
   // Otherwise, display an SSL blocking page.
-  new SSLBlockingPage(tab, cert_error, ssl_info, request_url, overridable,
-                      strict_enforcement, callback);
+  SSLBlockingPage::Show(tab, cert_error, ssl_info, request_url, overridable,
+                        strict_enforcement, callback);
 }
 
 void ChromeContentBrowserClient::SelectClientCertificate(
diff --git a/chrome/browser/safe_browsing/safe_browsing_blocking_page.cc b/chrome/browser/safe_browsing/safe_browsing_blocking_page.cc
index 81c3f2a..b644b70 100644
--- a/chrome/browser/safe_browsing/safe_browsing_blocking_page.cc
+++ b/chrome/browser/safe_browsing/safe_browsing_blocking_page.cc
@@ -311,7 +311,7 @@ SafeBrowsingBlockingPage::SafeBrowsingBlockingPage(
   }
 
   interstitial_page_ = InterstitialPage::Create(
-      web_contents, IsMainPageLoadBlocked(unsafe_resources), url_, this);
+      web_contents, is_main_frame_load_blocked_, url_, this);
 }
 
 bool SafeBrowsingBlockingPage::CanShowMalwareDetailsOption() {
@@ -872,6 +872,20 @@ SafeBrowsingBlockingPage::UnsafeResourceMap*
 }
 
 // static
+SafeBrowsingBlockingPage* SafeBrowsingBlockingPage::CreateBlockingPage(
+    SafeBrowsingUIManager* ui_manager,
+    WebContents* web_contents,
+    const UnsafeResource& unsafe_resource) {
+  std::vector<UnsafeResource> resources;
+  resources.push_back(unsafe_resource);
+  // Set up the factory if this has not been done already (tests do that
+  // before this method is called).
+  if (!factory_)
+    factory_ = g_safe_browsing_blocking_page_factory_impl.Pointer();
+  return factory_->CreateSafeBrowsingPage(ui_manager, web_contents, resources);
+}
+
+// static
 void SafeBrowsingBlockingPage::ShowBlockingPage(
     SafeBrowsingUIManager* ui_manager,
     const UnsafeResource& unsafe_resource) {
@@ -892,14 +906,8 @@ void SafeBrowsingBlockingPage::ShowBlockingPage(
   if (!interstitial) {
     // There are no interstitial currently showing in that tab, go ahead and
     // show this interstitial.
-    std::vector<UnsafeResource> resources;
-    resources.push_back(unsafe_resource);
-    // Set up the factory if this has not been done already (tests do that
-    // before this method is called).
-    if (!factory_)
-      factory_ = g_safe_browsing_blocking_page_factory_impl.Pointer();
     SafeBrowsingBlockingPage* blocking_page =
-        factory_->CreateSafeBrowsingPage(ui_manager, web_contents, resources);
+        CreateBlockingPage(ui_manager, web_contents, unsafe_resource);
     blocking_page->interstitial_page_->Show();
     return;
   }
diff --git a/chrome/browser/safe_browsing/safe_browsing_blocking_page.h b/chrome/browser/safe_browsing/safe_browsing_blocking_page.h
index b5ac288..5c97bb0 100644
--- a/chrome/browser/safe_browsing/safe_browsing_blocking_page.h
+++ b/chrome/browser/safe_browsing/safe_browsing_blocking_page.h
@@ -61,6 +61,13 @@ class SafeBrowsingBlockingPage : public content::InterstitialPageDelegate {
 
   virtual ~SafeBrowsingBlockingPage();
 
+  // Creates a blocking page. Use ShowBlockingPage if you don't need to access
+  // the blocking page directly.
+  static SafeBrowsingBlockingPage* CreateBlockingPage(
+      SafeBrowsingUIManager* ui_manager,
+      content::WebContents* web_contents,
+      const UnsafeResource& unsafe_resource);
+
   // Shows a blocking page warning the user about phishing/malware for a
   // specific resource.
   // You can call this method several times, if an interstitial is already
diff --git a/chrome/browser/ssl/ssl_blocking_page.cc b/chrome/browser/ssl/ssl_blocking_page.cc
index 458a166..fe67ddd 100644
--- a/chrome/browser/ssl/ssl_blocking_page.cc
+++ b/chrome/browser/ssl/ssl_blocking_page.cc
@@ -362,9 +362,12 @@ SSLBlockingPage::SSLBlockingPage(
                  content::Source<Profile>(profile));
 #endif
 
+  // chrome://interstitials page uses this class without actually creating an
+  // interstitial so that it can be debugged. Set |create_interstitial| to true
+  // if the page is going to be used as an actual interstitial and not just part
+  // of the chrome://interstitials webui.
   interstitial_page_ = InterstitialPage::Create(
       web_contents_, true, request_url, this);
-  interstitial_page_->Show();
 }
 
 SSLBlockingPage::~SSLBlockingPage() {
@@ -384,6 +387,41 @@ SSLBlockingPage::~SSLBlockingPage() {
   }
 }
 
+// static
+void SSLBlockingPage::Show(content::WebContents* web_contents,
+                           int cert_error,
+                           const net::SSLInfo& ssl_info,
+                           const GURL& request_url,
+                           bool overridable,
+                           bool strict_enforcement,
+                           const base::Callback<void(bool)>& callback) {
+  SSLBlockingPage* ssl_blocking_page = new SSLBlockingPage(web_contents,
+                                                           cert_error,
+                                                           ssl_info,
+                                                           request_url,
+                                                           overridable,
+                                                           strict_enforcement,
+                                                           callback);
+  ssl_blocking_page->interstitial_page_->Show();
+}
+
+// static
+SSLBlockingPage* SSLBlockingPage::CreateForWebUI(
+    content::WebContents* web_contents,
+    int cert_error,
+    const net::SSLInfo& ssl_info,
+    const GURL& request_url,
+    bool overridable,
+    bool strict_enforcement) {
+  return new SSLBlockingPage(web_contents,
+                             cert_error,
+                             ssl_info,
+                             request_url,
+                             overridable,
+                             strict_enforcement,
+                             base::Callback<void(bool)>());
+}
+
 std::string SSLBlockingPage::GetHTMLContents() {
   if (trial_condition_ == kCondV1 || trial_condition_ == kCondV1LayoutV2Text)
     return GetHTMLContentsV1();
diff --git a/chrome/browser/ssl/ssl_blocking_page.h b/chrome/browser/ssl/ssl_blocking_page.h
index f9782cd..51c2c13 100644
--- a/chrome/browser/ssl/ssl_blocking_page.h
+++ b/chrome/browser/ssl/ssl_blocking_page.h
@@ -48,16 +48,29 @@ class SSLBlockingPage : public content::InterstitialPageDelegate,
     CMD_CLOCK = 5
   };
 
-  SSLBlockingPage(
-      content::WebContents* web_contents,
-      int cert_error,
-      const net::SSLInfo& ssl_info,
-      const GURL& request_url,
-      bool overridable,
-      bool strict_enforcement,
-      const base::Callback<void(bool)>& callback);
   virtual ~SSLBlockingPage();
 
+  // Creates an SSL blocking page and an interstitial for it, and shows the
+  // interstitial. The interstitial owns the blocking page and is owned by
+  // |web_contents|.
+  static void Show(content::WebContents* web_contents,
+                   int cert_error,
+                   const net::SSLInfo& ssl_info,
+                   const GURL& request_url,
+                   bool overridable,
+                   bool strict_enforcement,
+                   const base::Callback<void(bool)>& callback);
+
+  // Creates an SSL blocking page and an interstitial for it without
+  // showing the interstitial. Since the interstitial isn't shown, the caller is
+  // responsible for cleaning up the blocking page.
+  static SSLBlockingPage* CreateForWebUI(content::WebContents* web_contents,
+                                         int cert_error,
+                                         const net::SSLInfo& ssl_info,
+                                         const GURL& request_url,
+                                         bool overridable,
+                                         bool strict_enforcement);
+
   // A method that sets strings in the specified dictionary from the passed
   // vector so that they can be used to resource the ssl_roadblock.html/
   // ssl_error.html files.
@@ -76,6 +89,15 @@ class SSLBlockingPage : public content::InterstitialPageDelegate,
   virtual void OnDontProceed() OVERRIDE;
 
  private:
+  SSLBlockingPage(
+      content::WebContents* web_contents,
+      int cert_error,
+      const net::SSLInfo& ssl_info,
+      const GURL& request_url,
+      bool overridable,
+      bool strict_enforcement,
+      const base::Callback<void(bool)>& callback);
+
   void NotifyDenyCertificate();
   void NotifyAllowCertificate();
 
diff --git a/chrome/browser/ui/webui/chrome_web_ui_controller_factory.cc b/chrome/browser/ui/webui/chrome_web_ui_controller_factory.cc
index 58456aa..1225735 100644
--- a/chrome/browser/ui/webui/chrome_web_ui_controller_factory.cc
+++ b/chrome/browser/ui/webui/chrome_web_ui_controller_factory.cc
@@ -35,6 +35,7 @@
 #include "chrome/browser/ui/webui/identity_internals_ui.h"
 #include "chrome/browser/ui/webui/inspect_ui.h"
 #include "chrome/browser/ui/webui/instant_ui.h"
+#include "chrome/browser/ui/webui/interstitials/interstitial_ui.h"
 #include "chrome/browser/ui/webui/invalidations_ui.h"
 #include "chrome/browser/ui/webui/memory_internals/memory_internals_ui.h"
 #include "chrome/browser/ui/webui/net_internals/net_internals_ui.h"
@@ -290,6 +291,8 @@ WebUIFactoryFunction GetWebUIFactoryFunction(WebUI* web_ui,
     return &NewWebUI<HistoryUI>;
   if (url.host() == chrome::kChromeUIInstantHost)
     return &NewWebUI<InstantUI>;
+  if (url.host() == chrome::kChromeUIInterstitialHost)
+    return &NewWebUI<InterstitialUI>;
   if (url.host() == chrome::kChromeUIInvalidationsHost)
     return &NewWebUI<InvalidationsUI>;
   if (url.host() == chrome::kChromeUISupervisedUserPassphrasePageHost)
diff --git a/chrome/browser/ui/webui/interstitials/interstitial_ui.cc b/chrome/browser/ui/webui/interstitials/interstitial_ui.cc
new file mode 100644
index 0000000..7221154
--- /dev/null
+++ b/chrome/browser/ui/webui/interstitials/interstitial_ui.cc
@@ -0,0 +1,200 @@
+// Copyright 2014 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/webui/interstitials/interstitial_ui.h"
+
+#include "base/strings/string_util.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
+#include "chrome/browser/safe_browsing/safe_browsing_service.h"
+#include "chrome/browser/ssl/ssl_blocking_page.h"
+#include "chrome/common/url_constants.h"
+#include "content/public/browser/interstitial_page_delegate.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_ui.h"
+#include "content/public/browser/web_ui_controller.h"
+#include "content/public/browser/web_ui_data_source.h"
+#include "grit/browser_resources.h"
+#include "net/base/net_errors.h"
+#include "net/base/url_util.h"
+#include "net/cert/x509_certificate.h"
+#include "net/ssl/ssl_info.h"
+
+namespace {
+
+class InterstitialHTMLSource : public content::URLDataSource {
+ public:
+  InterstitialHTMLSource(Profile* profile,
+                         content::WebContents* web_contents);
+  virtual ~InterstitialHTMLSource();
+
+  // content::URLDataSource:
+  virtual std::string GetMimeType(const std::string& mime_type) const OVERRIDE;
+  virtual std::string GetSource() const OVERRIDE;
+  virtual bool ShouldAddContentSecurityPolicy() const OVERRIDE;
+  virtual void StartDataRequest(
+      const std::string& path,
+      int render_process_id,
+      int render_frame_id,
+      const content::URLDataSource::GotDataCallback& callback) OVERRIDE;
+
+ private:
+  Profile* profile_;
+  content::WebContents* web_contents_;
+  DISALLOW_COPY_AND_ASSIGN(InterstitialHTMLSource);
+};
+
+SSLBlockingPage* CreateSSLBlockingPage(content::WebContents* web_contents) {
+  // Random parameters for SSL blocking page.
+  int cert_error = net::ERR_CERT_CONTAINS_ERRORS;
+  GURL request_url("https://example.com");
+  bool overridable = false;
+  bool strict_enforcement = false;
+  std::string url_param;
+  if (net::GetValueForKeyInQuery(web_contents->GetURL(),
+                                 "url",
+                                 &url_param)) {
+    if (GURL(url_param).is_valid())
+      request_url = GURL(url_param);
+  }
+  std::string overridable_param;
+  if (net::GetValueForKeyInQuery(web_contents->GetURL(),
+                                 "overridable",
+                                 &overridable_param)) {
+    overridable = overridable_param == "1";
+  }
+  std::string strict_enforcement_param;
+  if (net::GetValueForKeyInQuery(web_contents->GetURL(),
+                                 "strict_enforcement",
+                                 &strict_enforcement_param)) {
+    strict_enforcement = strict_enforcement_param == "1";
+  }
+  net::SSLInfo ssl_info;
+  ssl_info.cert = new net::X509Certificate(
+      request_url.host(), "CA", base::Time::Max(), base::Time::Max());
+  // This delegate doesn't create an interstitial.
+  return SSLBlockingPage::CreateForWebUI(web_contents, cert_error, ssl_info,
+                                         request_url, overridable,
+                                         strict_enforcement);
+}
+
+SafeBrowsingBlockingPage* CreateSafeBrowsingBlockingPage(
+    content::WebContents* web_contents) {
+  SBThreatType threat_type = SB_THREAT_TYPE_URL_MALWARE;
+  GURL request_url("http://example.com");
+  std::string url_param;
+  if (net::GetValueForKeyInQuery(web_contents->GetURL(),
+                                 "url",
+                                 &url_param)) {
+    if (GURL(url_param).is_valid())
+      request_url = GURL(url_param);
+  }
+  std::string type_param;
+  if (net::GetValueForKeyInQuery(web_contents->GetURL(),
+                                 "type",
+                                 &type_param)) {
+    if (type_param == "malware") {
+      threat_type =  SB_THREAT_TYPE_URL_MALWARE;
+    } else if (type_param == "phishing") {
+      threat_type = SB_THREAT_TYPE_URL_PHISHING;
+    } else if (type_param == "clientside_malware") {
+      threat_type = SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL;
+    } else if (type_param == "clientside_phishing") {
+      threat_type = SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL;
+      // Interstitials for client side phishing urls load after the page loads
+      // (see SafeBrowsingBlockingPage::IsMainPageLoadBlocked), so there should
+      // either be a new navigation entry, or there shouldn't be any pending
+      // entries. Clear any pending navigation entries.
+      content::NavigationController* controller =
+          &web_contents->GetController();
+      controller->DiscardNonCommittedEntries();
+    }
+  }
+  SafeBrowsingBlockingPage::UnsafeResource resource;
+  resource.url = request_url;
+  resource.threat_type =  threat_type;
+  return SafeBrowsingBlockingPage::CreateBlockingPage(
+      g_browser_process->safe_browsing_service()->ui_manager(),
+      web_contents,
+      resource);
+}
+
+} //  namespace
+
+InterstitialUI::InterstitialUI(content::WebUI* web_ui)
+    : WebUIController(web_ui) {
+  Profile* profile = Profile::FromWebUI(web_ui);
+  scoped_ptr<InterstitialHTMLSource> html_source(
+      new InterstitialHTMLSource(profile->GetOriginalProfile(),
+                                 web_ui->GetWebContents()));
+  content::URLDataSource::Add(profile, html_source.release());
+}
+
+InterstitialUI::~InterstitialUI() {
+}
+
+// InterstitialHTMLSource
+
+InterstitialHTMLSource::InterstitialHTMLSource(
+    Profile* profile,
+    content::WebContents* web_contents)
+    : profile_(profile),
+      web_contents_(web_contents) {
+}
+
+InterstitialHTMLSource::~InterstitialHTMLSource() {
+}
+
+std::string InterstitialHTMLSource::GetMimeType(
+    const std::string& mime_type) const {
+  return "text/html";
+}
+
+std::string InterstitialHTMLSource::GetSource() const {
+  return chrome::kChromeUIInterstitialHost;
+}
+
+bool InterstitialHTMLSource::ShouldAddContentSecurityPolicy()
+    const {
+  return false;
+}
+
+void InterstitialHTMLSource::StartDataRequest(
+    const std::string& path,
+    int render_process_id,
+    int render_frame_id,
+    const content::URLDataSource::GotDataCallback& callback) {
+  scoped_ptr<content::InterstitialPageDelegate> interstitial_delegate;
+  if (StartsWithASCII(path, "ssl", true)) {
+    interstitial_delegate.reset(CreateSSLBlockingPage(web_contents_));
+  } else if (StartsWithASCII(path, "safebrowsing", true)) {
+    interstitial_delegate.reset(CreateSafeBrowsingBlockingPage(web_contents_));
+  }
+
+  std::string html;
+  if (interstitial_delegate.get()) {
+    html = interstitial_delegate.get()->GetHTMLContents();
+  } else {
+    html = "<html><head><title>Interstitials</title></head>"
+           "<body><h2>Choose an interstitial<h2>"
+           "<h3>SSL</h3>"
+           "<a href='ssl'>example.com</a><br>"
+           "<a href='ssl?url=https://google.com'>SSL (google.com)</a><br>"
+           "<a href='ssl?overridable=1&strict_enforcement=0'>"
+           "    example.com (Overridable)</a>"
+           "<br><br>"
+           "<h3>SafeBrowsing</h3>"
+           "<a href='safebrowsing?type=malware'>Malware</a><br>"
+           "<a href='safebrowsing?type=phishing'>Phishing</a><br>"
+           "<a href='safebrowsing?type=clientside_malware'>"
+           "    Client Side Malware</a><br>"
+           "<a href='safebrowsing?type=clientside_phishing'>"
+           "    Client Side Phishing</a><br>"
+           "</body></html>";
+  }
+  scoped_refptr<base::RefCountedString> html_bytes = new base::RefCountedString;
+  html_bytes->data().assign(html.begin(), html.end());
+  callback.Run(html_bytes.get());
+}
diff --git a/chrome/browser/ui/webui/interstitials/interstitial_ui.h b/chrome/browser/ui/webui/interstitials/interstitial_ui.h
new file mode 100644
index 0000000..2506c8c
--- /dev/null
+++ b/chrome/browser/ui/webui/interstitials/interstitial_ui.h
@@ -0,0 +1,29 @@
+// Copyright 2014 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.
+
+#ifndef CHROME_BROWSER_UI_WEBUI_INTERSTITIALS_INTERSTITIAL_UI_H_
+#define CHROME_BROWSER_UI_WEBUI_INTERSTITIALS_INTERSTITIAL_UI_H_
+
+#include <string>
+
+#include "content/public/browser/url_data_source.h"
+#include "content/public/browser/web_ui_controller.h"
+
+class Profile;
+
+namespace content {
+class WebContents;
+}
+
+class InterstitialUI : public content::WebUIController {
+ public:
+  explicit InterstitialUI(content::WebUI* web_ui);
+
+  virtual ~InterstitialUI();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(InterstitialUI);
+};
+
+#endif  // CHROME_BROWSER_UI_WEBUI_INTERSTITIALS_INTERSTITIAL_UI_H_
diff --git a/chrome/browser/ui/webui/interstitials/interstitial_ui_browsertest.cc b/chrome/browser/ui/webui/interstitials/interstitial_ui_browsertest.cc
new file mode 100644
index 0000000..8047d03
--- /dev/null
+++ b/chrome/browser/ui/webui/interstitials/interstitial_ui_browsertest.cc
@@ -0,0 +1,59 @@
+// Copyright 2014 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 "base/strings/utf_string_conversions.h"
+#include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/devtools/devtools_window.h"
+#include "chrome/browser/devtools/devtools_window_testing.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "chrome/test/base/ui_test_utils.h"
+#include "content/public/browser/devtools_manager.h"
+#include "content/public/browser/web_contents.h"
+
+class InterstitialUITest : public InProcessBrowserTest {
+ public:
+   InterstitialUITest() {}
+   virtual ~InterstitialUITest() {}
+
+ protected:
+  void TestInterstitial(GURL url, const std::string& page_title) {
+    ui_test_utils::NavigateToURL(browser(), url);
+    EXPECT_EQ(
+      base::ASCIIToUTF16(page_title),
+      browser()->tab_strip_model()->GetActiveWebContents()->GetTitle());
+
+    // Should also be able to open and close devtools.
+    DevToolsWindow* window =
+        DevToolsWindowTesting::OpenDevToolsWindowSync(browser(), true);
+    EXPECT_TRUE(window);
+    DevToolsWindowTesting::CloseDevToolsWindowSync(window);
+  }
+};
+
+IN_PROC_BROWSER_TEST_F(InterstitialUITest, OpenInterstitial) {
+  TestInterstitial(
+      GURL("chrome://interstitials"),
+      "Interstitials");
+  // Invalid path should open the main page:
+  TestInterstitial(
+      GURL("chrome://interstitials/--invalid--"),
+      "Interstitials");
+  TestInterstitial(
+      GURL("chrome://interstitials/ssl"),
+      "Privacy error");
+  TestInterstitial(
+      GURL("chrome://interstitials/safebrowsing?type=malware"),
+      "Security error");
+  TestInterstitial(
+      GURL("chrome://interstitials/safebrowsing?type=phishing"),
+      "Security error");
+  TestInterstitial(
+      GURL("chrome://interstitials/safebrowsing?type=clientside_malware"),
+      "Security error");
+  TestInterstitial(
+      GURL("chrome://interstitials/safebrowsing?type=clientside_phishing"),
+      "Security error");
+}
diff --git a/chrome/chrome_browser_ui.gypi b/chrome/chrome_browser_ui.gypi
index a194db4..91861d7 100644
--- a/chrome/chrome_browser_ui.gypi
+++ b/chrome/chrome_browser_ui.gypi
@@ -1058,6 +1058,8 @@
       'browser/ui/webui/history_ui.h',
       'browser/ui/webui/instant_ui.cc',
       'browser/ui/webui/instant_ui.h',
+      'browser/ui/webui/interstitials/interstitial_ui.cc',
+      'browser/ui/webui/interstitials/interstitial_ui.h',
       'browser/ui/webui/invalidations_message_handler.cc',
       'browser/ui/webui/invalidations_message_handler.h',
       'browser/ui/webui/invalidations_ui.cc',
diff --git a/chrome/chrome_tests.gypi b/chrome/chrome_tests.gypi
index a5ddd61..e14c9ee 100644
--- a/chrome/chrome_tests.gypi
+++ b/chrome/chrome_tests.gypi
@@ -1472,6 +1472,7 @@
         'browser/ui/webui/identity_internals_ui_browsertest.h',
         'browser/ui/webui/identity_internals_ui_browsertest.js',
         'browser/ui/webui/inspect_ui_browsertest.cc',
+        'browser/ui/webui/interstitials/interstitial_ui_browsertest.cc',
         'browser/ui/webui/net_internals/net_internals_ui_browsertest.cc',
         'browser/ui/webui/net_internals/net_internals_ui_browsertest.h',
         'browser/ui/webui/ntp/most_visited_browsertest.cc',
diff --git a/chrome/common/url_constants.cc b/chrome/common/url_constants.cc
index 8dab267..6423b3f 100644
--- a/chrome/common/url_constants.cc
+++ b/chrome/common/url_constants.cc
@@ -58,6 +58,7 @@ const char kChromeUIHistoryFrameURL[] = "chrome://history-frame/";
 const char kChromeUIIdentityInternalsURL[] = "chrome://identity-internals/";
 const char kChromeUIInspectURL[] = "chrome://inspect/";
 const char kChromeUIInstantURL[] = "chrome://instant/";
+const char kChromeUIInterstitialURL[] = "chrome://interstitials/";
 const char kChromeUIInvalidationsURL[] = "chrome://invalidations/";
 const char kChromeUIIPCURL[] = "chrome://ipc/";
 const char kChromeUIMemoryRedirectURL[] = "chrome://memory-redirect/";
@@ -197,6 +198,7 @@ const char kChromeUIHistoryFrameHost[] = "history-frame";
 const char kChromeUIIdentityInternalsHost[] = "identity-internals";
 const char kChromeUIInspectHost[] = "inspect";
 const char kChromeUIInstantHost[] = "instant";
+const char kChromeUIInterstitialHost[] = "interstitials";
 const char kChromeUIInvalidationsHost[] = "invalidations";
 const char kChromeUIIPCHost[] = "ipc";
 const char kChromeUIKillHost[] = "kill";
diff --git a/chrome/common/url_constants.h b/chrome/common/url_constants.h
index 1022a18..c6653cf 100644
--- a/chrome/common/url_constants.h
+++ b/chrome/common/url_constants.h
@@ -52,6 +52,7 @@ extern const char kChromeUIHistoryFrameURL[];
 extern const char kChromeUIIdentityInternalsURL[];
 extern const char kChromeUIInspectURL[];
 extern const char kChromeUIInstantURL[];
+extern const char kChromeUIInterstitialURL[];
 extern const char kChromeUIInvalidationsURL[];
 extern const char kChromeUIIPCURL[];
 extern const char kChromeUIMemoryRedirectURL[];
@@ -186,6 +187,7 @@ extern const char kChromeUIHistoryFrameHost[];
 extern const char kChromeUIIdentityInternalsHost[];
 extern const char kChromeUIInspectHost[];
 extern const char kChromeUIInstantHost[];
+extern const char kChromeUIInterstitialHost[];
 extern const char kChromeUIInvalidationsHost[];
 extern const char kChromeUIIPCHost[];
 extern const char kChromeUIKillHost[];