Recreate the loader as soon as it is deleted and ensure that it does not become stale.

chrome/browser/instant/instant_controller.cc

 // 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/instant/instant_controller.h"
 
 #include "base/command_line.h"
 #include "base/i18n/case_conversion.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
@@ skipping 34 matching lines @@
 
 // An artificial delay (in milliseconds) we introduce before telling the Instant
 // page about the new omnibox bounds, in cases where the bounds shrink. This is
 // to avoid the page jumping up/down very fast in response to bounds changes.
 const int kUpdateBoundsDelayMS = 1000;
 
 // The maximum number of times we'll load a non-Instant-supporting search engine
 // before we give up and blacklist it for the rest of the browsing session.
 const int kMaxInstantSupportFailures = 10;
 
+// If an instant page has not been used in this much time, it is reloaded so
+// that the page does not become stale.

[sreeram, 2012/08/22 17:39:35]

// If an Instant page has not been used in these many milliseconds, ...

[Shishir, 2012/08/23 18:26:33]

Done.

+const int kInstantRefreshIntervalMS = 3 * 3600 * 1000;

[sreeram, 2012/08/22 17:39:35]

Perhaps call this kStaleLoaderTimeoutMS?

[Shishir, 2012/08/23 18:26:33]

Done.

+
 std::string ModeToString(InstantController::Mode mode) {
   switch (mode) {
     case InstantController::INSTANT:  return "_Instant";
     case InstantController::SUGGEST:  return "_Suggest";
     case InstantController::HIDDEN:   return "_Hidden";
     case InstantController::SILENT:   return "_Silent";
   }
 
   NOTREACHED();
   return std::string();
@@ skipping 96 matching lines @@
     return false;
   }
 
   string16 full_text = user_text + *suggested_text;
 
   if (full_text.empty()) {
     Hide();
     return false;
   }
 
+  // Rechedule the instant loader refresh.
+  ScheduleLoaderRefresh();
+
   // The presence of any suggested_text implies verbatim.
   DCHECK(suggested_text->empty() || verbatim)
       << user_text << "|" << *suggested_text;
 
   ResetLoader(instant_url, active_tab);
   last_active_tab_ = active_tab;
 
   // Track the non-Instant search URL for this query.
   url_for_history_ = match.destination_url;
   last_transition_type_ = match.transition;
@@ skipping 76 matching lines @@
   return !IsOutOfDate() && GetPreviewContents() && loader_->supports_instant();
 }
 
 TabContents* InstantController::CommitCurrentPreview(InstantCommitType type) {
   const TabContents* active_tab = delegate_->GetActiveTabContents();
   TabContents* preview = ReleasePreviewContents(type);
   AddSessionStorageHistogram(mode_, active_tab, preview);
   preview->web_contents()->GetController().CopyStateFromAndPrune(
       &active_tab->web_contents()->GetController());
   delegate_->CommitInstant(preview);
+
+  // Try to create another loader immediately so that it is ready for the next
+  // user interaction.
+  ResetLoaderWithDefaultUrlAndCurrentTab();
+
   return preview;
 }
 
 TabContents* InstantController::ReleasePreviewContents(InstantCommitType type) {
   TabContents* preview = loader_->ReleasePreviewContents(type, last_full_text_);
 
   // If the preview page has navigated since the last Update(), we need to add
   // the navigation to history ourselves. Else, the page will navigate after
   // commit, and it will be added to history in the usual manner.
   scoped_refptr<history::HistoryAddPageArgs> last_navigation =
@@ skipping 114 matching lines @@
   if (view_gaining_focus_ancestor) {
     CommitCurrentPreview(INSTANT_COMMIT_FOCUS_LOST);
     return;
   }
 
   Hide();
 #endif
 }
 
 void InstantController::OnAutocompleteGotFocus() {
-  const TabContents* active_tab = delegate_->GetActiveTabContents();
-
-  // We could get here with no active tab if the Browser is closing.
-  if (!active_tab)
-    return;
-
-  // Since we don't have any autocomplete match to work with, we'll just use
-  // the default search provider's Instant URL.
-  const TemplateURL* template_url =
-      TemplateURLServiceFactory::GetForProfile(active_tab->profile())->
-                                 GetDefaultSearchProvider();
-
-  std::string instant_url;
-  if (!GetInstantURL(template_url, &instant_url))
-    return;
-
-  ResetLoader(instant_url, active_tab);
+  ResetLoaderWithDefaultUrlAndCurrentTab();
 }
 
 bool InstantController::commit_on_pointer_release() const {
   return GetPreviewContents() && loader_->IsPointerDownFromActivate();
 }
 
 void InstantController::SetSuggestions(
     InstantLoader* loader,
     const std::vector<InstantSuggestion>& suggestions) {
   DCHECK_EQ(loader_.get(), loader);
@@ skipping 71 matching lines @@
   DCHECK_EQ(loader_.get(), loader);
   DCHECK(is_showing_ && !IsOutOfDate()) << is_showing_;
 #if defined(USE_AURA)
   // On aura the omnibox only receives a focus lost if we initiate the focus
   // change. This does that.
   if (is_showing_ && !IsOutOfDate())
     delegate_->InstantPreviewFocused();
 #endif
 }
 
+void InstantController::CreateLoader(const std::string& instant_url,
+                                     const TabContents* active_tab) {
+  DCHECK(!loader_.get());
+  loader_.reset(new InstantLoader(this, instant_url, active_tab));
+  loader_->Init();
+  ScheduleLoaderRefresh();
+  AddPreviewUsageForHistogram(mode_, PREVIEW_CREATED);
+}

[sreeram, 2012/08/22 17:39:35]

We don't need this method (CreateLoader) at all. We could just have these:

void ResetLoader(...) {
  if (GetPreviewContents() && ...)
    DeleteLoader();
  if (!GetPreviewContents()) {
    loader_.reset(...);
    loader_->Init();
    ResetStaleLoaderTimer();
    AddPreviewUsageForHistogram(...);
  }
}

void CreateDefaultLoader(...) {
  const TabContents* active_tab = ...;
  ...
  const TemplateURL* template_url = ...;
  ...
  ResetLoader(instant_url, active_tab);
}

void OnStaleLoader() {
  if (!is_showing_) {
    DeleteLoader();
    CreateDefaultLoader();
  }
}

void ResetStaleLoaderTimer() {
  stale_loader_timer_.Stop();
  stale_loader_timer_.Start(...);
}

[Shishir, 2012/08/23 18:26:33]

Done.

+
 void InstantController::ResetLoader(const std::string& instant_url,
                                     const TabContents* active_tab) {
   if (GetPreviewContents() && loader_->instant_url() != instant_url)
     DeleteLoader();
 
-  if (!GetPreviewContents()) {
-    loader_.reset(new InstantLoader(this, instant_url, active_tab));
-    loader_->Init();
-    AddPreviewUsageForHistogram(mode_, PREVIEW_CREATED);
+  if (!GetPreviewContents())
+    CreateLoader(instant_url, active_tab);
+}
+
+void InstantController::ResetLoaderWithDefaultUrlAndCurrentTab() {
+  const TabContents* active_tab = delegate_->GetActiveTabContents();
+
+  // We could get here with no active tab if the Browser is closing.
+  if (!active_tab)
+    return;
+
+  const TemplateURL* template_url =
+      TemplateURLServiceFactory::GetForProfile(active_tab->profile())->
+                                 GetDefaultSearchProvider();
+  std::string instant_url;
+  if (!GetInstantURL(template_url, &instant_url))
+    return;
+
+  ResetLoader(instant_url, active_tab);
+}
+
+void InstantController::ScheduleLoaderRefresh() {
+  if (loader_refresh_timer_.IsRunning()) {
+    loader_refresh_timer_.Reset();
+  } else {
+    loader_refresh_timer_.Start(
+        FROM_HERE,
+        base::TimeDelta::FromMilliseconds(kInstantRefreshIntervalMS), this,
+        &InstantController::RefreshLoader);
   }
 }
 
+void InstantController::RefreshLoader() {
+  // If the loader is showing, do not delete it, but reschedule a refresh.
+  if (is_showing_) {
+    ScheduleLoaderRefresh();
+    return;
+  }
+
+  DeleteLoader();
+  ResetLoaderWithDefaultUrlAndCurrentTab();
+}
+
 void InstantController::DeleteLoader() {
   Hide();
   last_full_text_.clear();
   last_user_text_.clear();
   last_verbatim_ = false;
   last_suggestion_ = InstantSuggestion();
   last_transition_type_ = content::PAGE_TRANSITION_LINK;
   last_omnibox_bounds_ = gfx::Rect();
   url_for_history_ = GURL();
   if (GetPreviewContents())
     AddPreviewUsageForHistogram(mode_, PREVIEW_DELETED);
+  loader_refresh_timer_.Stop();
   loader_.reset();
 }
 
 void InstantController::Show() {
   if (!is_showing_) {
     is_showing_ = true;
     delegate_->ShowInstant();
     AddPreviewUsageForHistogram(mode_, PREVIEW_SHOWED);
   }
 }
@@ skipping 52 matching lines @@
     return false;
   }
 
   return true;
 }
 
 bool InstantController::IsOutOfDate() const {
   return !last_active_tab_ ||
          last_active_tab_ != delegate_->GetActiveTabContents();
 }