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 24 IntranetRedirectDetector::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 44 IntranetRedirectDetector::~IntranetRedirectDetector() { 45 net::NetworkChangeNotifier::RemoveIPAddressObserver(this); 46 STLDeleteElements(&fetchers_); 47 } 48 49 // static 50 GURL 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 57 void IntranetRedirectDetector::RegisterPrefs(PrefRegistrySimple* registry) { 58 registry->RegisterStringPref(prefs::kLastKnownIntranetRedirectOrigin, 59 std::string()); 60 } 61 62 void 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 95 void 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 151 void 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
