DNS Prefetch fix: renderer shouldn't send long hostnames to browser.

chrome/browser/net/predictor_browsertest.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 "base/base64.h"
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/net/chrome_net_log.h"
@@ skipping 12 matching lines @@
 #include "net/dns/mock_host_resolver.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using content::BrowserThread;
 using testing::HasSubstr;
 
 namespace {
 
 const char kBlinkPreconnectFeature[] = "LinkPreconnect";
 const char kChromiumHostname[] = "chromium.org";
+const char kInvalidLongHostname[] = "illegally-long-hostname-over-255-"
+    "characters-should-not-send-an-ipc-message-to-the-browser-"
+    "0000000000000000000000000000000000000000000000000000000000000000000000000"
+    "0000000000000000000000000000000000000000000000000000000000000000000000000"
+    "000000000000000000000000000000000000000000000000000000.org";
 
 // Records a history of all hostnames for which resolving has been requested,
 // and immediately fails the resolution requests themselves.
 class HostResolutionRequestRecorder : public net::HostResolverProc {
  public:
   HostResolutionRequestRecorder()
       : HostResolverProc(NULL),
         is_waiting_for_hostname_(false) {
   }
 
   int Resolve(const std::string& host,
               net::AddressFamily address_family,
               net::HostResolverFlags host_resolver_flags,
               net::AddressList* addrlist,
               int* os_error) override {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&HostResolutionRequestRecorder::AddToHistory,
                    base::Unretained(this),
                    host));
     return net::ERR_NAME_NOT_RESOLVED;
   }
 
-  bool HasHostBeenRequested(const std::string& hostname) {
+  int RequestedHostnameCount() const {
+    return requested_hostnames_.size();
+  }
+
+  bool HasHostBeenRequested(const std::string& hostname) const {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     return std::find(requested_hostnames_.begin(),
                      requested_hostnames_.end(),
                      hostname) != requested_hostnames_.end();
   }
 
   void WaitUntilHostHasBeenRequested(const std::string& hostname) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DCHECK(!is_waiting_for_hostname_);
     if (HasHostBeenRequested(hostname))
@@ skipping 135 matching lines @@
   }
 
   void GetListFromPrefsAsString(const char* list_path,
                                 std::string* value_as_string) const {
     PrefService* prefs = browser()->profile()->GetPrefs();
     const base::ListValue* list_value = prefs->GetList(list_path);
     JSONStringValueSerializer serializer(value_as_string);
     serializer.Serialize(*list_value);
   }
 
+  bool HasHostBeenRequested(const std::string& hostname) const {
+    return host_resolution_request_recorder_->HasHostBeenRequested(hostname);
+  }
+
   void WaitUntilHostHasBeenRequested(const std::string& hostname) {
     host_resolution_request_recorder_->WaitUntilHostHasBeenRequested(hostname);
   }
 
+  int RequestedHostnameCount() const {
+    return host_resolution_request_recorder_->RequestedHostnameCount();
+  }
+
   const GURL startup_url_;
   const GURL referring_url_;
   const GURL target_url_;
 
  private:
   scoped_refptr<HostResolutionRequestRecorder>
       host_resolution_request_recorder_;
   scoped_ptr<net::ScopedDefaultHostResolverProc> scoped_host_resolver_proc_;
 };
 
@@ skipping 20 matching lines @@
 
   // But also make sure this data has been first loaded into the Predictor, by
   // inspecting that the Predictor starts making the expected hostname requests.
   PrepareFrameSubresources(referring_url_);
   WaitUntilHostHasBeenRequested(startup_url_.host());
   WaitUntilHostHasBeenRequested(target_url_.host());
 }
 
 IN_PROC_BROWSER_TEST_F(PredictorBrowserTest, DnsPrefetch) {
   ASSERT_TRUE(test_server()->Start());
+  int hostnames_requested_before_load = RequestedHostnameCount();
   ui_test_utils::NavigateToURL(
       browser(),
       GURL(test_server()->GetURL("files/predictor/dns_prefetch.html")));
   WaitUntilHostHasBeenRequested(kChromiumHostname);
+  ASSERT_FALSE(HasHostBeenRequested(kInvalidLongHostname));
+  ASSERT_EQ(hostnames_requested_before_load + 1, RequestedHostnameCount());
 }
 
 IN_PROC_BROWSER_TEST_F(PredictorBrowserTest, Preconnect) {
   ASSERT_TRUE(test_server()->Start());
 
   // Create a HTML preconnect reference to the local server in the form
   // <link rel="preconnect" href="http://test-server/">
   // and navigate to it as a data URI.
   GURL preconnect_url = test_server()->GetURL("");
   std::string preconnect_content =
       "<link rel=\"preconnect\" href=\"" + preconnect_url.spec() + "\">";
   std::string encoded;
   base::Base64Encode(preconnect_content, &encoded);
   std::string data_uri = "data:text/html;base64," + encoded;
 
   net::HostPortPair host_port_pair = net::HostPortPair::FromURL(preconnect_url);
   ConnectNetLogObserver net_log_observer(host_port_pair.ToString());
   net_log_observer.Attach();
 
   ui_test_utils::NavigateToURL(browser(), GURL(data_uri));
 
   net_log_observer.WaitForConnect();
   net_log_observer.Detach();
 }
 
 }  // namespace chrome_browser_net