Fixes bug in instant that resulted in flickery fade. The problem would

chrome/browser/instant/instant_controller.cc

 // Copyright (c) 2010 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 "build/build_config.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 20 matching lines @@
 static const int kUpdateDelayMS = 200;
 
 // static
 InstantController::HostBlacklist* InstantController::host_blacklist_ = NULL;
 
 InstantController::InstantController(Profile* profile,
                                      InstantDelegate* delegate)
     : delegate_(delegate),
       tab_contents_(NULL),
       is_active_(false),
+      is_displayable_(false),
       commit_on_mouse_up_(false),
       last_transition_type_(PageTransition::LINK),
       ALLOW_THIS_IN_INITIALIZER_LIST(destroy_factory_(this)),
       type_(FIRST_TYPE) {
   bool enabled = GetType(profile, &type_);
   DCHECK(enabled);
   PrefService* service = profile->GetPrefs();
   if (service) {
     // kInstantWasEnabledOnce was added after instant, set it now to make sure
     // it is correctly set.
@@ skipping 98 matching lines @@
 
   if (tab_contents != tab_contents_)
     DestroyPreviewContents();
 
   const GURL& url = match.destination_url;
   tab_contents_ = tab_contents;
   commit_on_mouse_up_ = false;
   last_transition_type_ = match.transition;
   const TemplateURL* template_url = NULL;
 
-  if (url.is_empty() || !url.is_valid() ||
-      !ShouldShowPreviewFor(match, &template_url)) {
+  if (url.is_empty() || !url.is_valid()) {
+    // Assume we were invoked with GURL() and should destroy all.
     DestroyPreviewContents();
     return;
   }
 
+  if (!ShouldShowPreviewFor(match, &template_url)) {
+    DestroyAndLeaveActive();
+    return;
+  }
+
   if (!loader_manager_.get())
     loader_manager_.reset(new InstantLoaderManager(this));
 
-  if (!is_active_)
+  if (!is_active_) {
+    is_active_ = true;
     delegate_->PrepareForInstant();
+  }
 
   TemplateURLID template_url_id = template_url ? template_url->id() : 0;
   // Verbatim only makes sense if the search engines supports instant.
   bool real_verbatim = template_url_id ? verbatim : false;
 
   if (ShouldUpdateNow(template_url_id, match.destination_url)) {
     UpdateLoader(template_url, match.destination_url, match.transition,
                  user_text, real_verbatim, suggested_text);
   } else {
     ScheduleUpdate(match.destination_url);
@@ skipping 19 matching lines @@
       loader_manager_->pending_loader()->SetOmniboxBounds(bounds);
   }
 }
 
 void InstantController::DestroyPreviewContents() {
   if (!loader_manager_.get()) {
     // We're not showing anything, nothing to do.
     return;
   }
 
+  // ReleasePreviewContents sets is_active_ to false, but we need to set it
+  // beore notifying the delegate so.
+  is_active_ = false;
   delegate_->HideInstant();
   delete ReleasePreviewContents(INSTANT_COMMIT_DESTROY);
 }
 
 bool InstantController::IsCurrent() {
-  return loader_manager_.get() && loader_manager_->active_loader()->ready() &&
-      !update_timer_.IsRunning();
+  return loader_manager_.get() && loader_manager_->active_loader() &&
+      loader_manager_->active_loader()->ready() && !update_timer_.IsRunning();
 }
 
 void InstantController::CommitCurrentPreview(InstantCommitType type) {
   DCHECK(loader_manager_.get());
   DCHECK(loader_manager_->current_loader());
   TabContentsWrapper* tab = ReleasePreviewContents(type);
   delegate_->CommitInstant(tab);
   CompleteRelease(tab->tab_contents());
 }
 
 void InstantController::SetCommitOnMouseUp() {
   commit_on_mouse_up_ = true;
 }
 
 bool InstantController::IsMouseDownFromActivate() {
   DCHECK(loader_manager_.get());
   DCHECK(loader_manager_->current_loader());
   return loader_manager_->current_loader()->IsMouseDownFromActivate();
 }
 
 void InstantController::OnAutocompleteLostFocus(
     gfx::NativeView view_gaining_focus) {
-  if (!is_active() || !GetPreviewContents())
+  if (!is_active() || !GetPreviewContents()) {
+    DestroyPreviewContents();
     return;
+  }
 
   RenderWidgetHostView* rwhv =
       GetPreviewContents()->tab_contents()->GetRenderWidgetHostView();
   if (!view_gaining_focus || !rwhv) {
     DestroyPreviewContents();
     return;
   }
 
   gfx::NativeView tab_view =
       GetPreviewContents()->tab_contents()->GetNativeView();
@@ skipping 45 matching lines @@
 
   // Loader may be null if the url blacklisted instant.
   scoped_ptr<InstantLoader> loader;
   if (loader_manager_->current_loader())
     loader.reset(loader_manager_->ReleaseCurrentLoader());
   TabContentsWrapper* tab = loader.get() ?
       loader->ReleasePreviewContents(type) : NULL;
 
   ClearBlacklist();
   is_active_ = false;
+  is_displayable_ = false;
+  commit_on_mouse_up_ = false;
   omnibox_bounds_ = gfx::Rect();
-  commit_on_mouse_up_ = false;
-  loader_manager_.reset(NULL);
+  loader_manager_.reset();
   update_timer_.Stop();
   return tab;
 }
 
 void InstantController::CompleteRelease(TabContents* tab) {
   tab->SetAllContentsBlocked(false);
 }
 
 TabContentsWrapper* InstantController::GetPreviewContents() {
-  return loader_manager_.get() ?
+  return loader_manager_.get() && loader_manager_->current_loader() ?
       loader_manager_->current_loader()->preview_contents() : NULL;
 }
 
 bool InstantController::IsShowingInstant() {
-  return loader_manager_.get() &&
+  return loader_manager_.get() && loader_manager_->current_loader() &&
       loader_manager_->current_loader()->is_showing_instant();
 }
 
 bool InstantController::MightSupportInstant() {
-  return loader_manager_.get() &&
+  return loader_manager_.get() && loader_manager_->active_loader() &&
       loader_manager_->active_loader()->is_showing_instant();
 }
 
 void InstantController::ShowInstantLoader(InstantLoader* loader) {
   DCHECK(loader_manager_.get());
   if (loader_manager_->current_loader() == loader) {
-    is_active_ = true;
+    is_displayable_ = true;
     delegate_->ShowInstant(loader->preview_contents());
   } else if (loader_manager_->pending_loader() == loader) {
     scoped_ptr<InstantLoader> old_loader;
     loader_manager_->MakePendingCurrent(&old_loader);
     delegate_->ShowInstant(loader->preview_contents());
   } else {
     // The loader supports instant but isn't active yet. Nothing to do.
   }
 
   NotificationService::current()->Notify(
@@ skipping 25 matching lines @@
     // revert.
     DestroyPreviewContents();
   }
 }
 
 void InstantController::InstantLoaderDoesntSupportInstant(
     InstantLoader* loader) {
   DCHECK(!loader->ready());  // We better not be showing this loader.
   DCHECK(loader->template_url_id());
 
-  VLOG(1) << " provider does not support instant";
+  VLOG(1) << "provider does not support instant";
 
   // Don't attempt to use instant for this search engine again.
   BlacklistFromInstant(loader->template_url_id());
 
   if (loader_manager_->active_loader() == loader) {
-    // The loader is active, shut down instant.
-    DestroyPreviewContents();
+    // The loader is active, hide all.
+    DestroyAndLeaveActive();
   } else {
-    if (loader_manager_->current_loader() == loader && is_active_) {
+    if (loader_manager_->current_loader() == loader && is_displayable_) {
       // There is a pending loader and we're active. Hide the preview. When then
       // pending loader finishes loading we'll notify the delegate to show.
       DCHECK(loader_manager_->pending_loader());
-      is_active_ = false;
+      is_displayable_ = false;
       delegate_->HideInstant();
     }
     loader_manager_->DestroyLoader(loader);
   }
 }
 
 void InstantController::AddToBlacklist(InstantLoader* loader, const GURL& url) {
   std::string host = url.host();
   if (host.empty())
     return;
 
   if (!host_blacklist_)
     host_blacklist_ = new HostBlacklist;
   host_blacklist_->insert(host);
 
   if (!loader_manager_.get())
     return;
 
   // Because of the state of the stack we can't destroy the loader now.
   ScheduleDestroy(loader);
 
   loader_manager_->ReleaseLoader(loader);
-  if (is_active_ &&
+  if (is_displayable_ &&
       (!loader_manager_->active_loader() ||
        !loader_manager_->current_loader()->ready())) {
     // Hide instant. When the pending loader finishes loading we'll go active
     // again.
-    is_active_ = false;
+    is_displayable_ = false;
     delegate_->HideInstant();
   }
 }
 
+void InstantController::DestroyAndLeaveActive() {
+  is_displayable_ = false;
+  commit_on_mouse_up_ = false;
+  delegate_->HideInstant();
+
+  loader_manager_.reset(new InstantLoaderManager(this));
+  update_timer_.Stop();
+}
+
+TabContentsWrapper* InstantController::GetPendingPreviewContents() {
+  return loader_manager_.get() && loader_manager_->pending_loader() ?
+      loader_manager_->pending_loader()->preview_contents() : NULL;
+}
+
 bool InstantController::ShouldUpdateNow(TemplateURLID instant_id,
                                         const GURL& url) {
   DCHECK(loader_manager_.get());
 
   if (instant_id) {
     // Update sites that support instant immediately, they can do their own
     // throttling.
     return true;
   }
 
   if (url.SchemeIsFile())
     return true;  // File urls should load quickly, so don't delay loading them.
 
   if (loader_manager_->WillUpateChangeActiveLoader(instant_id)) {
     // If Update would change loaders, update now. This indicates transitioning
     // from an instant to non-instant loader.
     return true;
   }
 
   InstantLoader* active_loader = loader_manager_->active_loader();
   // WillUpateChangeActiveLoader should return true if no active loader, so
   // we know there will be an active loader if we get here.
   DCHECK(active_loader);
-  // Immediately update if the hosts differ, otherwise we'll delay the update.
-  return active_loader->url().host() != url.host();
+  // Immediately update if the url is the same (which should result in nothing
+  // happening) or the hosts differ, otherwise we'll delay the update.
+  return (active_loader->url() == url) ||
+      (active_loader->url().host() != url.host());
 }
 
 void InstantController::ScheduleUpdate(const GURL& url) {
   scheduled_url_ = url;
 
   if (update_timer_.IsRunning())
     update_timer_.Stop();
   update_timer_.Start(base::TimeDelta::FromMilliseconds(kUpdateDelayMS),
                       this, &InstantController::ProcessScheduledUpdate);
 }
@@ skipping 145 matching lines @@
       return "Predictive";
     case VERBATIM_TYPE:
       return "Verbatim";
     case PREDICTIVE_NO_AUTO_COMPLETE_TYPE:
       return "PredictiveNoAutoComplete";
     default:
       NOTREACHED();
       return std::string();
   }
 }