1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/intranet_redirect_detector.h"
6
7#include "base/bind.h"
8#include "base/command_line.h"
9#include "base/prefs/pref_registry_simple.h"
10#include "base/prefs/pref_service.h"
11#include "base/rand_util.h"
12#include "base/stl_util.h"
13#include "base/strings/utf_string_conversions.h"
14#include "chrome/browser/browser_process.h"
15#include "chrome/common/chrome_switches.h"
16#include "chrome/common/pref_names.h"
17#include "net/base/load_flags.h"
18#include "net/base/net_errors.h"
19#include "net/base/registry_controlled_domains/registry_controlled_domain.h"
20#include "net/url_request/url_fetcher.h"
21#include "net/url_request/url_request_context_getter.h"
22#include "net/url_request/url_request_status.h"
23
24IntranetRedirectDetector::IntranetRedirectDetector()
25    : redirect_origin_(g_browser_process->local_state()->GetString(
26          prefs::kLastKnownIntranetRedirectOrigin)),
27      in_sleep_(true),
28      weak_ptr_factory_(this) {
29  // Because this function can be called during startup, when kicking off a URL
30  // fetch can eat up 20 ms of time, we delay seven seconds, which is hopefully
31  // long enough to be after startup, but still get results back quickly.
32  // Ideally, instead of this timer, we'd do something like "check if the
33  // browser is starting up, and if so, come back later", but there is currently
34  // no function to do this.
35  static const int kStartFetchDelaySeconds = 7;
36  base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
37      base::Bind(&IntranetRedirectDetector::FinishSleep,
38                 weak_ptr_factory_.GetWeakPtr()),
39      base::TimeDelta::FromSeconds(kStartFetchDelaySeconds));
40
41  net::NetworkChangeNotifier::AddIPAddressObserver(this);
42}
43
44IntranetRedirectDetector::~IntranetRedirectDetector() {
45  net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
46  STLDeleteElements(&fetchers_);
47}
48
49// static
50GURL IntranetRedirectDetector::RedirectOrigin() {
51  const IntranetRedirectDetector* const detector =
52      g_browser_process->intranet_redirect_detector();
53  return detector ? detector->redirect_origin_ : GURL();
54}
55
56// static
57void IntranetRedirectDetector::RegisterPrefs(PrefRegistrySimple* registry) {
58  registry->RegisterStringPref(prefs::kLastKnownIntranetRedirectOrigin,
59                               std::string());
60}
61
62void IntranetRedirectDetector::FinishSleep() {
63  in_sleep_ = false;
64
65  // If another fetch operation is still running, cancel it.
66  STLDeleteElements(&fetchers_);
67  resulting_origins_.clear();
68
69  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
70  if (cmd_line->HasSwitch(switches::kDisableBackgroundNetworking))
71    return;
72
73  DCHECK(fetchers_.empty() && resulting_origins_.empty());
74
75  // Start three fetchers on random hostnames.
76  for (size_t i = 0; i < 3; ++i) {
77    std::string url_string("http://");
78    // We generate a random hostname with between 7 and 15 characters.
79    const int num_chars = base::RandInt(7, 15);
80    for (int j = 0; j < num_chars; ++j)
81      url_string += ('a' + base::RandInt(0, 'z' - 'a'));
82    GURL random_url(url_string + '/');
83    net::URLFetcher* fetcher = net::URLFetcher::Create(
84        random_url, net::URLFetcher::HEAD, this);
85    // We don't want these fetches to affect existing state in the profile.
86    fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE |
87                          net::LOAD_DO_NOT_SAVE_COOKIES |
88                          net::LOAD_DO_NOT_SEND_COOKIES);
89    fetcher->SetRequestContext(g_browser_process->system_request_context());
90    fetcher->Start();
91    fetchers_.insert(fetcher);
92  }
93}
94
95void IntranetRedirectDetector::OnURLFetchComplete(
96    const net::URLFetcher* source) {
97  // Delete the fetcher on this function's exit.
98  Fetchers::iterator fetcher = fetchers_.find(
99      const_cast<net::URLFetcher*>(source));
100  DCHECK(fetcher != fetchers_.end());
101  scoped_ptr<net::URLFetcher> clean_up_fetcher(*fetcher);
102  fetchers_.erase(fetcher);
103
104  // If any two fetches result in the same domain/host, we set the redirect
105  // origin to that; otherwise we set it to nothing.
106  if (!source->GetStatus().is_success() || (source->GetResponseCode() != 200)) {
107    if ((resulting_origins_.empty()) ||
108        ((resulting_origins_.size() == 1) &&
109         resulting_origins_.front().is_valid())) {
110      resulting_origins_.push_back(GURL());
111      return;
112    }
113    redirect_origin_ = GURL();
114  } else {
115    DCHECK(source->GetURL().is_valid());
116    GURL origin(source->GetURL().GetOrigin());
117    if (resulting_origins_.empty()) {
118      resulting_origins_.push_back(origin);
119      return;
120    }
121    if (net::registry_controlled_domains::SameDomainOrHost(
122        resulting_origins_.front(),
123        origin,
124        net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES)) {
125      redirect_origin_ = origin;
126      if (!fetchers_.empty()) {
127        // Cancel remaining fetch, we don't need it.
128        DCHECK(fetchers_.size() == 1);
129        delete (*fetchers_.begin());
130        fetchers_.clear();
131      }
132    }
133    if (resulting_origins_.size() == 1) {
134      resulting_origins_.push_back(origin);
135      return;
136    }
137    DCHECK(resulting_origins_.size() == 2);
138    const bool same_domain_or_host =
139        net::registry_controlled_domains::SameDomainOrHost(
140            resulting_origins_.back(),
141            origin,
142            net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
143    redirect_origin_ = same_domain_or_host ? origin : GURL();
144  }
145
146  g_browser_process->local_state()->SetString(
147      prefs::kLastKnownIntranetRedirectOrigin, redirect_origin_.is_valid() ?
148          redirect_origin_.spec() : std::string());
149}
150
151void IntranetRedirectDetector::OnIPAddressChanged() {
152  // If a request is already scheduled, do not scheduled yet another one.
153  if (in_sleep_)
154    return;
155
156  // Since presumably many programs open connections after network changes,
157  // delay this a little bit.
158  in_sleep_ = true;
159  static const int kNetworkSwitchDelayMS = 1000;
160  base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
161      base::Bind(&IntranetRedirectDetector::FinishSleep,
162                 weak_ptr_factory_.GetWeakPtr()),
163      base::TimeDelta::FromMilliseconds(kNetworkSwitchDelayMS));
164}
165