src/chrome/browser/ui/search/instant_ntp_prerenderer.cc

   1 // Copyright 2013 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/ui/search/instant_ntp_prerenderer.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/bind.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "build/build_config.h"
  12 #include "chrome/browser/chrome_notification_types.h"
  13 #include "chrome/browser/content_settings/content_settings_provider.h"
  14 #include "chrome/browser/content_settings/host_content_settings_map.h"
  15 #include "chrome/browser/profiles/profile.h"
  16 #include "chrome/browser/search/instant_service.h"
  17 #include "chrome/browser/search/instant_service_factory.h"
  18 #include "chrome/browser/search/search.h"
  19 #include "chrome/browser/ui/browser.h"
  20 #include "chrome/browser/ui/browser_finder.h"
  21 #include "chrome/browser/ui/host_desktop.h"
  22 #include "chrome/browser/ui/search/instant_ntp.h"
  23 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  24 #include "chrome/common/content_settings.h"
  25 #include "chrome/common/pref_names.h"
  26 #include "chrome/common/search_urls.h"
  27 #include "content/public/browser/notification_service.h"
  28 #include "content/public/browser/render_process_host.h"
  29 #include "content/public/browser/web_contents.h"
  30 #include "net/base/network_change_notifier.h"
  31
  32 namespace {
  33
  34 void DeleteNTPSoon(scoped_ptr<InstantNTP> ntp) {
  35   if (!ntp)
  36     return;
  37
  38   if (ntp->contents()) {
  39     base::MessageLoop::current()->DeleteSoon(
  40         FROM_HERE, ntp->ReleaseContents().release());
  41   }
  42   base::MessageLoop::current()->DeleteSoon(FROM_HERE, ntp.release());
  43 }
  44
  45 }  // namespace
  46
  47
  48 InstantNTPPrerenderer::InstantNTPPrerenderer(Profile* profile,
  49                                              InstantService* instant_service,
  50                                              PrefService* prefs)
  51     : profile_(profile) {
  52   DCHECK(profile);
  53
  54   // In unit tests, prefs may be NULL.
  55   if (prefs) {
  56     profile_pref_registrar_.Init(prefs);
  57     profile_pref_registrar_.Add(
  58         prefs::kSearchSuggestEnabled,
  59         base::Bind(&InstantNTPPrerenderer::ReloadInstantNTP,
  60                    base::Unretained(this)));
  61   }
  62   net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
  63
  64   // Allow instant_service to be null for unit tets.
  65   if (instant_service)
  66     instant_service->AddObserver(this);
  67 }
  68
  69 InstantNTPPrerenderer::~InstantNTPPrerenderer() {
  70   InstantService* instant_service =
  71       InstantServiceFactory::GetForProfile(profile_);
  72   if (instant_service)
  73     instant_service->RemoveObserver(this);
  74   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
  75 }
  76
  77 void InstantNTPPrerenderer::ReloadInstantNTP() {
  78   ResetNTP(GetInstantURL());
  79 }
  80
  81 scoped_ptr<content::WebContents> InstantNTPPrerenderer::ReleaseNTPContents() {
  82   if (!profile_ || profile_->IsOffTheRecord() ||
  83       !chrome::ShouldShowInstantNTP())
  84     return scoped_ptr<content::WebContents>();
  85
  86   if (ShouldSwitchToLocalNTP())
  87     ResetNTP(GetLocalInstantURL());
  88
  89   scoped_ptr<content::WebContents> ntp_contents = ntp_->ReleaseContents();
  90
  91   // Preload a new InstantNTP.
  92   ReloadInstantNTP();
  93   return ntp_contents.Pass();
  94 }
  95
  96 content::WebContents* InstantNTPPrerenderer::GetNTPContents() const {
  97   return ntp() ? ntp()->contents() : NULL;
  98 }
  99
 100 void InstantNTPPrerenderer::DeleteNTPContents() {
 101   if (ntp_)
 102     ntp_.reset();
 103 }
 104
 105 void InstantNTPPrerenderer::RenderProcessGone() {
 106   DeleteNTPSoon(ntp_.Pass());
 107 }
 108
 109 void InstantNTPPrerenderer::LoadCompletedMainFrame() {
 110   if (!ntp_ || ntp_->supports_instant())
 111     return;
 112
 113   content::WebContents* ntp_contents = ntp_->contents();
 114   DCHECK(ntp_contents);
 115
 116   InstantService* instant_service =
 117       InstantServiceFactory::GetForProfile(profile());
 118   if (instant_service &&
 119       instant_service->IsInstantProcess(
 120           ntp_contents->GetRenderProcessHost()->GetID())) {
 121     return;
 122   }
 123   InstantSupportDetermined(ntp_contents, false);
 124 }
 125
 126 std::string InstantNTPPrerenderer::GetLocalInstantURL() const {
 127   return chrome::GetLocalInstantURL(profile_).spec();
 128 }
 129
 130 std::string InstantNTPPrerenderer::GetInstantURL() const {
 131   if (net::NetworkChangeNotifier::IsOffline())
 132     return GetLocalInstantURL();
 133
 134   // TODO(kmadhusu): Remove start margin param from chrome::GetInstantURL().
 135   const GURL instant_url = chrome::GetInstantURL(profile_,
 136                                                  chrome::kDisableStartMargin,
 137                                                  false);
 138   if (!instant_url.is_valid())
 139     return GetLocalInstantURL();
 140
 141   return instant_url.spec();
 142 }
 143
 144 bool InstantNTPPrerenderer::IsJavascriptEnabled() const {
 145   GURL instant_url(GetInstantURL());
 146   GURL origin(instant_url.GetOrigin());
 147   ContentSetting js_setting = profile_->GetHostContentSettingsMap()->
 148       GetContentSetting(origin, origin, CONTENT_SETTINGS_TYPE_JAVASCRIPT,
 149                         NO_RESOURCE_IDENTIFIER);
 150   // Javascript can be disabled either in content settings or via a WebKit
 151   // preference, so check both. Disabling it through the Settings page affects
 152   // content settings. I'm not sure how to disable the WebKit preference, but
 153   // it's theoretically possible some users have it off.
 154   bool js_content_enabled =
 155       js_setting == CONTENT_SETTING_DEFAULT ||
 156       js_setting == CONTENT_SETTING_ALLOW;
 157   bool js_webkit_enabled = profile_->GetPrefs()->GetBoolean(
 158       prefs::kWebKitJavascriptEnabled);
 159   return js_content_enabled && js_webkit_enabled;
 160 }
 161
 162 bool InstantNTPPrerenderer::InStartup() const {
 163 #if !defined(OS_ANDROID)
 164   // TODO(kmadhusu): This is not completely reliable. Find a better way to
 165   // detect startup time.
 166   Browser* browser = chrome::FindBrowserWithProfile(profile_,
 167                                                     chrome::GetActiveDesktop());
 168   return !browser || !browser->tab_strip_model()->GetActiveWebContents();
 169 #endif
 170   return false;
 171 }
 172
 173 InstantNTP* InstantNTPPrerenderer::ntp() const {
 174   return ntp_.get();
 175 }
 176
 177 void InstantNTPPrerenderer::OnNetworkChanged(
 178     net::NetworkChangeNotifier::ConnectionType type) {
 179   // Not interested in events conveying change to offline.
 180   if (type == net::NetworkChangeNotifier::CONNECTION_NONE)
 181     return;
 182
 183   if (!ntp() || ntp()->IsLocal())
 184     ReloadInstantNTP();
 185 }
 186
 187 void InstantNTPPrerenderer::InstantSupportDetermined(
 188     const content::WebContents* contents,
 189     bool supports_instant) {
 190   DCHECK(ntp() && ntp()->contents() == contents);
 191
 192   if (!supports_instant) {
 193     bool is_local = ntp()->IsLocal();
 194     DeleteNTPSoon(ntp_.Pass());
 195     if (!is_local)
 196       ResetNTP(GetLocalInstantURL());
 197   }
 198
 199   content::NotificationService::current()->Notify(
 200       chrome::NOTIFICATION_INSTANT_NTP_SUPPORT_DETERMINED,
 201       content::Source<InstantNTPPrerenderer>(this),
 202       content::NotificationService::NoDetails());
 203 }
 204
 205 void InstantNTPPrerenderer::InstantPageAboutToNavigateMainFrame(
 206     const content::WebContents* /* contents */,
 207     const GURL& /* url */) {
 208   NOTREACHED();
 209 }
 210
 211 void InstantNTPPrerenderer::InstantPageLoadFailed(
 212     content::WebContents* contents) {
 213   DCHECK(ntp() && ntp()->contents() == contents);
 214
 215   bool is_local = ntp()->IsLocal();
 216   DeleteNTPSoon(ntp_.Pass());
 217   if (!is_local)
 218     ResetNTP(GetLocalInstantURL());
 219 }
 220
 221 void InstantNTPPrerenderer::ResetNTP(const std::string& instant_url) {
 222   // Instant NTP is only used in extended mode so we should always have a
 223   // non-empty URL to use.
 224   DCHECK(!instant_url.empty());
 225   if (!chrome::ShouldUseCacheableNTP()) {
 226     ntp_.reset(new InstantNTP(this, instant_url, profile_));
 227     ntp_->InitContents(base::Bind(&InstantNTPPrerenderer::ReloadInstantNTP,
 228                                   base::Unretained(this)));
 229   }
 230 }
 231
 232 bool InstantNTPPrerenderer::PageIsCurrent() const {
 233   const std::string& instant_url = GetInstantURL();
 234   if (instant_url.empty() ||
 235       !search::MatchesOriginAndPath(GURL(ntp()->instant_url()),
 236                                     GURL(instant_url)))
 237     return false;
 238
 239   return ntp()->supports_instant();
 240 }
 241
 242 bool InstantNTPPrerenderer::ShouldSwitchToLocalNTP() const {
 243   if (!ntp())
 244     return true;
 245
 246   // Assume users with Javascript disabled do not want the online experience.
 247   if (!IsJavascriptEnabled())
 248     return true;
 249
 250   // Already a local page. Not calling IsLocal() because we want to distinguish
 251   // between the Google-specific and generic local NTP.
 252   if (ntp()->instant_url() == GetLocalInstantURL())
 253     return false;
 254
 255   if (PageIsCurrent())
 256     return false;
 257
 258   // The preloaded NTP does not support instant yet. If we're not in startup,
 259   // always fall back to the local NTP. If we are in startup, use the local NTP
 260   // (unless the finch flag to use the remote NTP is set).
 261   return !(InStartup() && chrome::ShouldPreferRemoteNTPOnStartup());
 262 }
 263
 264 void InstantNTPPrerenderer::DefaultSearchProviderChanged() {
 265   ReloadInstantNTP();
 266 }
 267
 268 void InstantNTPPrerenderer::GoogleURLUpdated() {
 269   ReloadInstantNTP();
 270 }