// 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 "chrome/browser/google/google_url_tracker.h"
#include "base/bind.h"
#include "base/command_line.h"
#include "base/prefs/pref_service.h"
#include "base/strings/string_util.h"
#include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/google/google_url_tracker_factory.h"
#include "chrome/browser/google/google_url_tracker_infobar_delegate.h"
#include "chrome/browser/google/google_url_tracker_navigation_helper.h"
#include "chrome/browser/google/google_util.h"
#include "chrome/browser/infobars/infobar.h"
#include "chrome/browser/infobars/infobar_service.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/pref_names.h"
#include "content/public/browser/navigation_controller.h"
#include "content/public/browser/navigation_entry.h"
#include "content/public/browser/notification_service.h"
#include "net/base/load_flags.h"
#include "net/base/net_util.h"
#include "net/url_request/url_fetcher.h"
#include "net/url_request/url_request_status.h"
const char GoogleURLTracker::kDefaultGoogleHomepage[] =
"http://www.google.com/";
const char GoogleURLTracker::kSearchDomainCheckURL[] =
"https://www.google.com/searchdomaincheck?format=url&type=chrome";
GoogleURLTracker::GoogleURLTracker(
Profile* profile,
scoped_ptr<GoogleURLTrackerNavigationHelper> nav_helper,
Mode mode)
: profile_(profile),
nav_helper_(nav_helper.Pass()),
infobar_creator_(base::Bind(&GoogleURLTrackerInfoBarDelegate::Create)),
google_url_(mode == UNIT_TEST_MODE ? kDefaultGoogleHomepage :
profile->GetPrefs()->GetString(prefs::kLastKnownGoogleURL)),
weak_ptr_factory_(this),
fetcher_id_(0),
in_startup_sleep_(true),
already_fetched_(false),
need_to_fetch_(false),
need_to_prompt_(false),
search_committed_(false) {
net::NetworkChangeNotifier::AddIPAddressObserver(this);
nav_helper_->SetGoogleURLTracker(this);
// Because this function can be called during startup, when kicking off a URL
// fetch can eat up 20 ms of time, we delay five 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.
//
// In UNIT_TEST mode, where we want to explicitly control when the tracker
// "wakes up", we do nothing at all.
if (mode == NORMAL_MODE) {
static const int kStartFetchDelayMS = 5000;
base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
base::Bind(&GoogleURLTracker::FinishSleep,
weak_ptr_factory_.GetWeakPtr()),
base::TimeDelta::FromMilliseconds(kStartFetchDelayMS));
}
}
GoogleURLTracker::~GoogleURLTracker() {
// We should only reach here after any tabs and their infobars have been torn
// down.
DCHECK(entry_map_.empty());
}
// static
GURL GoogleURLTracker::GoogleURL(Profile* profile) {
const GoogleURLTracker* tracker =
GoogleURLTrackerFactory::GetForProfile(profile);
return tracker ? tracker->google_url_ : GURL(kDefaultGoogleHomepage);
}
// static
void GoogleURLTracker::RequestServerCheck(Profile* profile, bool force) {
GoogleURLTracker* tracker = GoogleURLTrackerFactory::GetForProfile(profile);
// If the tracker already has a fetcher, SetNeedToFetch() is unnecessary, and
// changing |already_fetched_| is wrong.
if (tracker && !tracker->fetcher_) {
if (force)
tracker->already_fetched_ = false;
tracker->SetNeedToFetch();
}
}
// static
void GoogleURLTracker::GoogleURLSearchCommitted(Profile* profile) {
GoogleURLTracker* tracker = GoogleURLTrackerFactory::GetForProfile(profile);
if (tracker)
tracker->SearchCommitted();
}
void GoogleURLTracker::AcceptGoogleURL(bool redo_searches) {
UpdatedDetails urls(google_url_, fetched_google_url_);
google_url_ = fetched_google_url_;
PrefService* prefs = profile_->GetPrefs();
prefs->SetString(prefs::kLastKnownGoogleURL, google_url_.spec());
prefs->SetString(prefs::kLastPromptedGoogleURL, google_url_.spec());
content::NotificationService::current()->Notify(
chrome::NOTIFICATION_GOOGLE_URL_UPDATED,
content::Source<Profile>(profile_),
content::Details<UpdatedDetails>(&urls));
need_to_prompt_ = false;
CloseAllEntries(redo_searches);
}
void GoogleURLTracker::CancelGoogleURL() {
profile_->GetPrefs()->SetString(prefs::kLastPromptedGoogleURL,
fetched_google_url_.spec());
need_to_prompt_ = false;
CloseAllEntries(false);
}
void GoogleURLTracker::OnURLFetchComplete(const net::URLFetcher* source) {
// Delete the fetcher on this function's exit.
scoped_ptr<net::URLFetcher> clean_up_fetcher(fetcher_.release());
// Don't update the URL if the request didn't succeed.
if (!source->GetStatus().is_success() || (source->GetResponseCode() != 200)) {
already_fetched_ = false;
return;
}
// See if the response data was valid. It should be
// "<scheme>://[www.]google.<TLD>/".
std::string url_str;
source->GetResponseAsString(&url_str);
TrimWhitespace(url_str, TRIM_ALL, &url_str);
GURL url(url_str);
if (!url.is_valid() || (url.path().length() > 1) || url.has_query() ||
url.has_ref() ||
!google_util::IsGoogleDomainUrl(url, google_util::DISALLOW_SUBDOMAIN,
google_util::DISALLOW_NON_STANDARD_PORTS))
return;
std::swap(url, fetched_google_url_);
GURL last_prompted_url(
profile_->GetPrefs()->GetString(prefs::kLastPromptedGoogleURL));
if (last_prompted_url.is_empty()) {
// On the very first run of Chrome, when we've never looked up the URL at
// all, we should just silently switch over to whatever we get immediately.
AcceptGoogleURL(true); // Arg is irrelevant.
return;
}
base::string16 fetched_host(net::StripWWWFromHost(fetched_google_url_));
if (fetched_google_url_ == google_url_) {
// Either the user has continually been on this URL, or we prompted for a
// different URL but have now changed back before they responded to any of
// the prompts. In this latter case we want to close any infobars and stop
// prompting.
CancelGoogleURL();
} else if (fetched_host == net::StripWWWFromHost(google_url_)) {
// Similar to the above case, but this time the new URL differs from the
// existing one, probably due to switching between HTTP and HTTPS searching.
// Like before we want to close any infobars and stop prompting; we also
// want to silently accept the change in scheme. We don't redo open
// searches so as to avoid suddenly changing a page the user might be
// interacting with; it's enough to simply get future searches right.
AcceptGoogleURL(false);
} else if (fetched_host == net::StripWWWFromHost(last_prompted_url)) {
// We've re-fetched a TLD the user previously turned down. Although the new
// URL might have a different scheme than the old, we want to preserve the
// user's decision. Note that it's possible that, like in the above two
// cases, we fetched yet another different URL in the meantime, which we
// have infobars prompting about; in this case, as in those above, we want
// to go ahead and close the infobars and stop prompting, since we've
// switched back away from that URL.
CancelGoogleURL();
} else {
// We've fetched a URL with a different TLD than the user is currently using
// or was previously prompted about. This means we need to prompt again.
need_to_prompt_ = true;
// As in all the above cases, there could be infobars prompting about some
// URL. If these URLs have the same TLD (e.g. for scheme changes), we can
// simply leave the existing infobars open as their messages will still be
// accurate. Otherwise we go ahead and close them because we need to
// display a new message.
// Note: |url| is the previous |fetched_google_url_|.
if (url.is_valid() && (fetched_host != net::StripWWWFromHost(url)))
CloseAllEntries(false);
}
}
void GoogleURLTracker::OnIPAddressChanged() {
already_fetched_ = false;
StartFetchIfDesirable();
}
void GoogleURLTracker::Shutdown() {
nav_helper_.reset();
weak_ptr_factory_.InvalidateWeakPtrs();
fetcher_.reset();
net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
}
void GoogleURLTracker::DeleteMapEntryForService(
const InfoBarService* infobar_service) {
// WARNING: |infobar_service| may point to a deleted object. Do not
// dereference it! See OnTabClosed().
EntryMap::iterator i(entry_map_.find(infobar_service));
DCHECK(i != entry_map_.end());
GoogleURLTrackerMapEntry* map_entry = i->second;
UnregisterForEntrySpecificNotifications(*map_entry, false);
entry_map_.erase(i);
delete map_entry;
}
void GoogleURLTracker::SetNeedToFetch() {
need_to_fetch_ = true;
StartFetchIfDesirable();
}
void GoogleURLTracker::FinishSleep() {
in_startup_sleep_ = false;
StartFetchIfDesirable();
}
void GoogleURLTracker::StartFetchIfDesirable() {
// 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.
//
// See comments in header on the class, on RequestServerCheck(), and on the
// various members here for more detail on exactly what the conditions are.
if (in_startup_sleep_ || already_fetched_ || !need_to_fetch_)
return;
// Some switches should disable the Google URL tracker entirely. If we can't
// do background networking, we can't do the necessary fetch, and if the user
// specified a Google base URL manually, we shouldn't bother to look up any
// alternatives or offer to switch to them.
if (CommandLine::ForCurrentProcess()->HasSwitch(
switches::kDisableBackgroundNetworking) ||
CommandLine::ForCurrentProcess()->HasSwitch(switches::kGoogleBaseURL))
return;
std::string fetch_url = CommandLine::ForCurrentProcess()->
GetSwitchValueASCII(switches::kGoogleSearchDomainCheckURL);
if (fetch_url.empty())
fetch_url = kSearchDomainCheckURL;
already_fetched_ = true;
fetcher_.reset(net::URLFetcher::Create(fetcher_id_, GURL(fetch_url),
net::URLFetcher::GET, this));
++fetcher_id_;
// We don't want this fetch to set new entries in the cache or cookies, lest
// we alarm the user.
fetcher_->SetLoadFlags(net::LOAD_DISABLE_CACHE |
net::LOAD_DO_NOT_SAVE_COOKIES);
fetcher_->SetRequestContext(profile_->GetRequestContext());
// Configure to max_retries at most kMaxRetries times for 5xx errors.
static const int kMaxRetries = 5;
fetcher_->SetMaxRetriesOn5xx(kMaxRetries);
fetcher_->Start();
}
void GoogleURLTracker::SearchCommitted() {
if (need_to_prompt_) {
search_committed_ = true;
// These notifications will fire a bit later in the same call chain we're
// currently in.
if (!nav_helper_->IsListeningForNavigationStart())
nav_helper_->SetListeningForNavigationStart(true);
}
}
void GoogleURLTracker::OnNavigationPending(
content::NavigationController* navigation_controller,
InfoBarService* infobar_service,
int pending_id) {
EntryMap::iterator i(entry_map_.find(infobar_service));
if (search_committed_) {
search_committed_ = false;
// Whether there's an existing infobar or not, we need to listen for the
// load to commit, so we can show and/or update the infobar when it does.
// (We may already be registered for this if there is an existing infobar
// that had a previous pending search that hasn't yet committed.)
if (!nav_helper_->IsListeningForNavigationCommit(navigation_controller)) {
nav_helper_->SetListeningForNavigationCommit(navigation_controller,
true);
}
if (i == entry_map_.end()) {
// This is a search on a tab that doesn't have one of our infobars, so
// prepare to add one. Note that we only listen for the tab's destruction
// on this path; if there was already a map entry, then either it doesn't
// yet have an infobar and we're already registered for this, or it has an
// infobar and the infobar's owner will handle tearing it down when the
// tab is destroyed.
nav_helper_->SetListeningForTabDestruction(navigation_controller, true);
entry_map_.insert(std::make_pair(
infobar_service,
new GoogleURLTrackerMapEntry(this, infobar_service,
navigation_controller)));
} else if (i->second->has_infobar_delegate()) {
// This is a new search on a tab where we already have an infobar.
i->second->infobar_delegate()->set_pending_id(pending_id);
}
} else if (i != entry_map_.end()){
if (i->second->has_infobar_delegate()) {
// This is a non-search navigation on a tab with an infobar. If there was
// a previous pending search on this tab, this means it won't commit, so
// undo anything we did in response to seeing that. Note that if there
// was no pending search on this tab, these statements are effectively a
// no-op.
//
// If this navigation actually commits, that will trigger the infobar's
// owner to expire the infobar if need be. If it doesn't commit, then
// simply leaving the infobar as-is will have been the right thing.
UnregisterForEntrySpecificNotifications(*i->second, false);
i->second->infobar_delegate()->set_pending_id(0);
} else {
// Non-search navigation on a tab with an entry that has not yet created
// an infobar. This means the original search won't commit, so delete the
// entry.
i->second->Close(false);
}
} else {
// Non-search navigation on a tab without an infobars. This is irrelevant
// to us.
}
}
void GoogleURLTracker::OnNavigationCommitted(InfoBarService* infobar_service,
const GURL& search_url) {
EntryMap::iterator i(entry_map_.find(infobar_service));
DCHECK(i != entry_map_.end());
GoogleURLTrackerMapEntry* map_entry = i->second;
DCHECK(search_url.is_valid());
UnregisterForEntrySpecificNotifications(*map_entry, true);
if (map_entry->has_infobar_delegate()) {
map_entry->infobar_delegate()->Update(search_url);
} else {
InfoBar* infobar = infobar_creator_.Run(infobar_service, this, search_url);
if (infobar) {
map_entry->SetInfoBarDelegate(
static_cast<GoogleURLTrackerInfoBarDelegate*>(infobar->delegate()));
} else {
map_entry->Close(false);
}
}
}
void GoogleURLTracker::OnTabClosed(
content::NavigationController* navigation_controller) {
// Because InfoBarService tears itself down on tab destruction, it's possible
// to get a non-NULL InfoBarService pointer here, depending on which order
// notifications fired in. Likewise, the pointer in |entry_map_| (and in its
// associated MapEntry) may point to deleted memory. Therefore, if we were to
// access the InfoBarService* we have for this tab, we'd need to ensure we
// just looked at the raw pointer value, and never dereferenced it. This
// function doesn't need to do even that, but others in the call chain from
// here might (and have comments pointing back here).
for (EntryMap::iterator i(entry_map_.begin()); i != entry_map_.end(); ++i) {
if (i->second->navigation_controller() == navigation_controller) {
i->second->Close(false);
return;
}
}
NOTREACHED();
}
void GoogleURLTracker::CloseAllEntries(bool redo_searches) {
// Delete all entries, whether they have infobars or not.
while (!entry_map_.empty())
entry_map_.begin()->second->Close(redo_searches);
}
void GoogleURLTracker::UnregisterForEntrySpecificNotifications(
const GoogleURLTrackerMapEntry& map_entry,
bool must_be_listening_for_commit) {
// For tabs with map entries but no infobars, we should always be listening
// for both these notifications. For tabs with infobars, we may be listening
// for navigation commits if the user has performed a new search on this tab.
if (nav_helper_->IsListeningForNavigationCommit(
map_entry.navigation_controller())) {
nav_helper_->SetListeningForNavigationCommit(
map_entry.navigation_controller(), false);
} else {
DCHECK(!must_be_listening_for_commit);
DCHECK(map_entry.has_infobar_delegate());
}
const bool registered_for_tab_destruction =
nav_helper_->IsListeningForTabDestruction(
map_entry.navigation_controller());
DCHECK_NE(registered_for_tab_destruction, map_entry.has_infobar_delegate());
if (registered_for_tab_destruction) {
nav_helper_->SetListeningForTabDestruction(
map_entry.navigation_controller(), false);
}
// Our global listeners for these other notifications should be in place iff
// we have any tabs still listening for commits. These tabs either have no
// infobars or have received new pending searches atop existing infobars; in
// either case we want to catch subsequent pending non-search navigations.
// See the various cases inside OnNavigationPending().
for (EntryMap::const_iterator i(entry_map_.begin()); i != entry_map_.end();
++i) {
if (nav_helper_->IsListeningForNavigationCommit(
i->second->navigation_controller())) {
DCHECK(nav_helper_->IsListeningForNavigationStart());
return;
}
}
if (nav_helper_->IsListeningForNavigationStart()) {
DCHECK(!search_committed_);
nav_helper_->SetListeningForNavigationStart(false);
}
}