// 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);
  }
}