Add autodetection of "intranet" redirection, for ISPs etc. that send typos an...

chrome/browser/intranet_redirect_detector.cc

Index: chrome/browser/intranet_redirect_detector.cc
===================================================================
--- chrome/browser/intranet_redirect_detector.cc	(revision 0)
+++ chrome/browser/intranet_redirect_detector.cc	(revision 0)
@@ -0,0 +1,171 @@
+// Copyright (c) 2010 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/intranet_redirect_detector.h"
+
+#include "base/rand_util.h"
+#include "base/stl_util-inl.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/profile.h"
+#include "chrome/common/notification_service.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/common/pref_service.h"
+#include "net/base/load_flags.h"
+#include "net/base/net_errors.h"
+#include "net/base/registry_controlled_domain.h"
+#include "net/url_request/url_request_status.h"
+
+const size_t IntranetRedirectDetector::kNumCharsInHostnames = 10;
+
+IntranetRedirectDetector::IntranetRedirectDetector()
+    : redirect_origin_(WideToUTF8(g_browser_process->local_state()->GetString(
+          prefs::kLastKnownIntranetRedirectOrigin))),
+      ALLOW_THIS_IN_INITIALIZER_LIST(fetcher_factory_(this)),
+      in_startup_sleep_(true),
+      request_context_available_(!!Profile::GetDefaultRequestContext()) {
+  registrar_.Add(this, NotificationType::DEFAULT_REQUEST_CONTEXT_AVAILABLE,
+                 NotificationService::AllSources());
+
+  // Because this function can be called during startup, when kicking off a URL
+  // fetch can eat up 20 ms of time, we delay seven seconds, which is hopefully
+  // long enough to be after startup, but still get results back quickly.
+  // Ideally, instead of this timer, we'd do something like "check if the
+  // browser is starting up, and if so, come back later", but there is currently
+  // no function to do this.
+  static const int kStartFetchDelayMS = 7000;
+  MessageLoop::current()->PostDelayedTask(FROM_HERE,
+      fetcher_factory_.NewRunnableMethod(
+          &IntranetRedirectDetector::FinishSleep),
+      kStartFetchDelayMS);
+}
+
+IntranetRedirectDetector::~IntranetRedirectDetector() {
+  STLDeleteElements(&fetchers_);
+}
+
+// static
+GURL IntranetRedirectDetector::RedirectOrigin() {
+  const IntranetRedirectDetector* const detector =
+      g_browser_process->intranet_redirect_detector();
+  return detector ? detector->redirect_origin_ : GURL();
+}
+
+// static
+void IntranetRedirectDetector::RegisterPrefs(PrefService* prefs) {
+  prefs->RegisterStringPref(prefs::kLastKnownIntranetRedirectOrigin,
+                            std::wstring());
+}
+
+void IntranetRedirectDetector::FinishSleep() {
+  in_startup_sleep_ = false;
+  StartFetchesIfPossible();
+}
+
+void IntranetRedirectDetector::StartFetchesIfPossible() {
+  // Bail if a fetch isn't appropriate right now.  This function will be called
+  // again each time one of the preconditions changes, so we'll fetch
+  // immediately once all of them are met.
+  if (in_startup_sleep_ || !request_context_available_)
+    return;
+
+  // We shouldn't somehow run twice.
+  DCHECK(fetchers_.empty() && resulting_origins_.empty());
+
+  // Start three fetchers on random hostnames.
+  for (size_t i = 0; i < 3; ++i) {
+    std::string url_string("http://");
+    for (size_t j = 0; j < kNumCharsInHostnames; ++j)
+      url_string += ('a' + base::RandInt(0, 'z' - 'a'));
+    GURL random_url(url_string + '/');
+    URLFetcher* fetcher = new URLFetcher(random_url, URLFetcher::HEAD, this);
+    // We don't want these fetches to affect existing state in the profile.
+    fetcher->set_load_flags(net::LOAD_DISABLE_CACHE |
+                            net::LOAD_DO_NOT_SAVE_COOKIES);
+    fetcher->set_request_context(Profile::GetDefaultRequestContext());
+    fetcher->Start();
+    fetchers_.insert(fetcher);
+  }
+}
+
+void IntranetRedirectDetector::OnURLFetchComplete(
+    const URLFetcher* source,
+    const GURL& url,
+    const URLRequestStatus& status,
+    int response_code,
+    const ResponseCookies& cookies,
+    const std::string& data) {
+  // Delete the fetcher on this function's exit.
+  Fetchers::iterator fetcher = fetchers_.find(const_cast<URLFetcher*>(source));
+  DCHECK(fetcher != fetchers_.end());
+  scoped_ptr<URLFetcher> clean_up_fetcher(*fetcher);
+  fetchers_.erase(fetcher);
+
+  // If any two fetches result in the same domain/host, we set the redirect
+  // origin to that; otherwise we set it to nothing.
+  if (!status.is_success() || (response_code != 200)) {
+    if ((resulting_origins_.empty()) ||
+        ((resulting_origins_.size() == 1) &&
+         resulting_origins_.front().is_valid())) {
+      resulting_origins_.push_back(GURL());
+      return;
+    }
+    redirect_origin_ = GURL();
+  } else {
+    DCHECK(url.is_valid());
+    GURL origin(url.GetOrigin());
+    if (resulting_origins_.empty()) {
+      resulting_origins_.push_back(origin);
+      return;
+    }
+    if (net::RegistryControlledDomainService::SameDomainOrHost(
+        resulting_origins_.front(), origin)) {
+      redirect_origin_ = origin;
+      if (!fetchers_.empty()) {
+        // Cancel remaining fetch, we don't need it.
+        DCHECK(fetchers_.size() == 1);
+        delete (*fetchers_.begin());
+        fetchers_.clear();
+      }
+    }
+    if (resulting_origins_.size() == 1) {
+      resulting_origins_.push_back(origin);
+      return;
+    }
+    DCHECK(resulting_origins_.size() == 2);
+    redirect_origin_ = net::RegistryControlledDomainService::SameDomainOrHost(
+        resulting_origins_.back(), origin) ? origin : GURL();
+  }
+
+  g_browser_process->local_state()->SetString(
+      prefs::kLastKnownIntranetRedirectOrigin, redirect_origin_.is_valid() ?
+          UTF8ToWide(redirect_origin_.spec()) : std::wstring());
+}
+
+void IntranetRedirectDetector::Observe(NotificationType type,
+                                       const NotificationSource& source,
+                                       const NotificationDetails& details) {
+  DCHECK_EQ(NotificationType::DEFAULT_REQUEST_CONTEXT_AVAILABLE, type.value);
+  request_context_available_ = true;
+  StartFetchesIfPossible();
+}
+
+IntranetRedirectHostResolverProc::IntranetRedirectHostResolverProc(
+    net::HostResolverProc* previous)
+    : net::HostResolverProc(previous) {
+}
+
+int IntranetRedirectHostResolverProc::Resolve(const std::string& host,
+                                              net::AddressFamily address_family,
+                                              net::AddressList* addrlist) {
+  // We'd love to just ask the IntranetRedirectDetector, but we may not be on
+  // the same thread.  So just use the heuristic that any all-lowercase a-z
+  // hostname with the right number of characters is likely from the detector
+  // (and thus should be blocked).
+  return ((host.length() == IntranetRedirectDetector::kNumCharsInHostnames) &&
+      (host.find_first_not_of("abcdefghijklmnopqrstuvwxyz") ==
+          std::string::npos)) ?
+      net::ERR_NAME_NOT_RESOLVED :
+      ResolveUsingPrevious(host, address_family, addrlist);
+}
Property changes on: chrome/browser/intranet_redirect_detector.cc
___________________________________________________________________
Added: svn:eol-style
   + LF