Adding local html page used in Instant Extended mode when instant is disabled or unavailable.

chrome/browser/instant/instant_controller.cc

 // Copyright 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/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 128 matching lines @@
 
   return false;
 }
 
 bool IsFullHeight(const InstantModel& model) {
   return model.height() == 100 && model.height_units() == INSTANT_SIZE_PERCENT;
 }
 
 }  // namespace
 
+// static
+const char* InstantController::kLocalOmniboxPopupURL =
+    "chrome://local-omnibox-popup/local-omnibox-popup.html";
+
 InstantController::InstantController(chrome::BrowserInstantController* browser,
-                                     bool extended_enabled)
+                                     bool extended_enabled,
+                                     bool use_local_preview_only)
     : browser_(browser),
       extended_enabled_(extended_enabled),
       instant_enabled_(false),
+      use_local_preview_only_(use_local_preview_only),
       model_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       last_omnibox_text_has_inline_autocompletion_(false),
       last_verbatim_(false),
       last_transition_type_(content::PAGE_TRANSITION_LINK),
       last_match_was_search_(false),
       omnibox_focus_state_(OMNIBOX_FOCUS_NONE),
       allow_preview_to_show_search_suggestions_(false) {
 }
 
 InstantController::~InstantController() {
@@ skipping 281 matching lines @@
       instant_tab_->Submit(last_omnibox_text_);
       instant_tab_->contents()->Focus();
       return true;
     }
     return false;
   }
 
   if (!IsPreviewingSearchResults() && type != INSTANT_COMMIT_NAVIGATED)
     return false;
 
+  // Never commit the local omnibox.
+  if (loader_->IsUsingLocalPreview())
+    return false;
+
   if (type == INSTANT_COMMIT_FOCUS_LOST)
     loader_->Cancel(last_omnibox_text_);
   else if (type != INSTANT_COMMIT_NAVIGATED &&
            type != INSTANT_COMMIT_CLICKED_QUERY_SUGGESTION)
     loader_->Submit(last_omnibox_text_);
 
   content::WebContents* preview = loader_->ReleaseContents();
 
   if (extended_enabled_) {
     // Consider what's happening:
@@ skipping 379 matching lines @@
 void InstantController::NavigateToURL(const GURL& url,
                                       content::PageTransition transition) {
   if (!extended_enabled_)
     return;
   if (loader_)
     HideLoader();
   browser_->OpenURLInCurrentTab(url, transition);
 }
 
 bool InstantController::ResetLoader(const TemplateURL* template_url,
-                                    const content::WebContents* active_tab) {
+                                    const content::WebContents* active_tab,
+                                    bool fallback_to_local) {
   std::string instant_url;
-  if (!GetInstantURL(template_url, &instant_url))
-    return false;
+  if (!GetInstantURL(template_url, &instant_url)) {
+    if (!fallback_to_local || !extended_enabled_)
+      return false;
+
+    // If we are in extended mode, fallback to the local popup.
+    instant_url = kLocalOmniboxPopupURL;
+  }
 
   if (loader_ && loader_->instant_url() == instant_url)
     return true;
 
   HideInternal();
   loader_.reset(new InstantLoader(this, instant_url));
   loader_->InitContents(active_tab);
 
   // Ensure the searchbox API has the correct initial state.
   if (extended_enabled_) {
@@ skipping 14 matching lines @@
 bool InstantController::CreateDefaultLoader() {
   // If there's no active tab, the browser is closing.
   const content::WebContents* active_tab = browser_->GetActiveWebContents();
   if (!active_tab)
     return false;
 
   const TemplateURL* template_url = TemplateURLServiceFactory::GetForProfile(
       Profile::FromBrowserContext(active_tab->GetBrowserContext()))->
       GetDefaultSearchProvider();
 
-  return ResetLoader(template_url, active_tab);
+  return ResetLoader(template_url, active_tab, true);
 }
 
 void InstantController::OnStaleLoader() {
+  // The local popup is never stale.
+  if (loader_ && loader_->IsUsingLocalPreview())
+    return;
+
   // If the preview is showing or the omnibox has focus, don't delete the
   // loader. It will get refreshed the next time the preview is hidden or the
   // omnibox loses focus.
   if (!stale_loader_timer_.IsRunning() &&
       omnibox_focus_state_ == OMNIBOX_FOCUS_NONE &&
       model_.mode().is_default()) {
     loader_.reset();
     CreateDefaultLoader();
   }
 }
@@ skipping 20 matching lines @@
   // of |match|, we shouldn't use the committed tab.
   if (instant_tab_)
     return true;
 
   // If there's no active tab, the browser is closing.
   const content::WebContents* active_tab = browser_->GetActiveWebContents();
   if (!active_tab)
     return false;
 
   // Try to create a loader for the instant_url in the TemplateURL of |match|.
+  // Do not fallback to the local preview because if the keyword specific
+  // instant URL fails, we want to first try the default instant URL which
+  // happens in the CreateDefaultLoader call below.
   const TemplateURL* template_url = match.GetTemplateURL(
       Profile::FromBrowserContext(active_tab->GetBrowserContext()), false);
-  if (ResetLoader(template_url, active_tab))
+  if (ResetLoader(template_url, active_tab, false))
     return true;
 
   // In non-extended mode, stop if we couldn't get a loader for the |match|.
   if (!extended_enabled_)
     return false;
 
   // If the match is a query, it is for a non-Instant search engine; stop.
   if (last_match_was_search_)
     return false;
 
@@ skipping 53 matching lines @@
   }
 
   // If the preview is being shown for the first time since the user started
   // typing, record a histogram value.
   if (!first_interaction_time_.is_null() && model_.mode().is_default()) {
     base::TimeDelta delta = base::Time::Now() - first_interaction_time_;
     UMA_HISTOGRAM_TIMES("Instant.TimeToFirstShow", delta);
   }
 
   // Show at 100% height except in the following cases:
+  // - The local omnibox popup is being loaded.
   // - Instant is disabled. The page needs to be able to show only a dropdown.
   // - The page wants to show custom NTP content.
   // - The page is over a website other than search or an NTP, and is not
   //   already showing at 100% height.
-  if (!instant_enabled_ || reason == INSTANT_SHOWN_CUSTOM_NTP_CONTENT ||
+  if (loader_->IsUsingLocalPreview() || !instant_enabled_ ||
+      reason == INSTANT_SHOWN_CUSTOM_NTP_CONTENT ||
       (search_mode_.is_origin_default() && !IsFullHeight(model_)))
     model_.SetPreviewState(search_mode_, height, units);
   else
     model_.SetPreviewState(search_mode_, 100, INSTANT_SIZE_PERCENT);
 
   // If the user clicked on a query suggestion, also go ahead and commit the
   // overlay. This is necessary because if the overlay was partially visible
   // when the suggestion was clicked, the click itself would not commit the
   // overlay (because we're not full height).
   if (reason == INSTANT_SHOWN_CLICKED_QUERY_SUGGESTION)
@@ skipping 22 matching lines @@
   // Mac fullscreen mode, the omnibox is fully enclosed by the preview bounds).
   DCHECK_LE(0, intersection.x());
   DCHECK_LE(0, intersection.width());
   DCHECK_LE(0, intersection.height());
 
   loader_->SetOmniboxBounds(intersection);
 }
 
 bool InstantController::GetInstantURL(const TemplateURL* template_url,
                                       std::string* instant_url) const {
+  if (extended_enabled_ && use_local_preview_only_) {
+    *instant_url = kLocalOmniboxPopupURL;
+    return true;
+  }
+
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kInstantURL)) {
     *instant_url = command_line->GetSwitchValueASCII(switches::kInstantURL);
     return template_url != NULL;
   }
 
   if (!template_url)
     return false;
 
   const TemplateURLRef& instant_url_ref = template_url->instant_url_ref();
@@ skipping 29 matching lines @@
   }
 
   std::map<std::string, int>::const_iterator iter =
       blacklisted_urls_.find(*instant_url);
   if (iter != blacklisted_urls_.end() &&
       iter->second > kMaxInstantSupportFailures)
     return false;
 
   return true;
 }