Fixes bug in instant where we wouldn't initially tell the page the

chrome/browser/instant/instant_loader.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_loader.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "app/l10n_util.h"
@@ skipping 40 matching lines @@
 // Header and value set for all loads.
 const char kPreviewHeader[] = "X-Purpose:";
 const char kPreviewHeaderValue[] = "preview";
 
 }  // namespace
 
 // FrameLoadObserver is responsible for determining if the page supports
 // instant after it has loaded.
 class InstantLoader::FrameLoadObserver : public NotificationObserver {
  public:
-  FrameLoadObserver(TabContents* tab_contents,
+  FrameLoadObserver(InstantLoader* loader,
+                    TabContents* tab_contents,
                     const string16& text,
                     bool verbatim)
-      : tab_contents_(tab_contents),
+      : loader_(loader),
+        tab_contents_(tab_contents),
         text_(text),
         verbatim_(verbatim),
         unique_id_(tab_contents_->controller().pending_entry()->unique_id()) {
     registrar_.Add(this, NotificationType::LOAD_COMPLETED_MAIN_FRAME,
                    Source<TabContents>(tab_contents_));
   }
 
   // Sets the text to send to the page.
   void set_text(const string16& text) { text_ = text; }
 
   // Sets whether verbatim results are obtained rather than predictive.
   void set_verbatim(bool verbatim) { verbatim_ = verbatim; }
 
   // NotificationObserver:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
     switch (type.value) {
       case NotificationType::LOAD_COMPLETED_MAIN_FRAME: {
         int page_id = *(Details<int>(details).ptr());
         NavigationEntry* active_entry =
             tab_contents_->controller().GetActiveEntry();
         if (!active_entry || active_entry->page_id() != page_id ||
             active_entry->unique_id() != unique_id_) {
           return;
         }
+        loader_->SendBoundsToPage(true);
         tab_contents_->render_view_host()->DetermineIfPageSupportsInstant(
             text_, verbatim_);
         break;
       }
       default:
         NOTREACHED();
         break;
     }
   }
 
  private:
+  InstantLoader* loader_;
+
   // The TabContents we're listening for changes on.
   TabContents* tab_contents_;
 
   // Text to send down to the page.
   string16 text_;
 
   // Whether verbatim results are obtained.
   bool verbatim_;
 
   // unique_id of the NavigationEntry we're waiting on.
@@ skipping 267 matching lines @@
     else
       loader_->SetCompleteSuggestedText(UTF8ToUTF16(suggestions[0]));
   }
 
   virtual void OnInstantSupportDetermined(int32 page_id, bool result) {
     TabContents* source = loader_->preview_contents()->tab_contents();
     if (!source->controller().GetActiveEntry() ||
         page_id != source->controller().GetActiveEntry()->page_id())
       return;
 
-    if (result) {
-      gfx::Rect bounds = loader_->GetOmniboxBoundsInTermsOfPreview();
-      loader_->last_omnibox_bounds_ = loader_->omnibox_bounds_;
+    if (result)
       loader_->PageFinishedLoading();
-    } else {
+    else
       loader_->PageDoesntSupportInstant(user_typed_before_load_);
-    }
   }
 
  private:
   typedef std::vector<scoped_refptr<history::HistoryAddPageArgs> >
       AddPageVector;
 
   void CommitFromMouseReleaseIfNecessary() {
     bool was_down = is_mouse_down_from_activate_;
     is_mouse_down_from_activate_ = false;
     if (was_down && loader_->ShouldCommitInstantOnMouseUp())
@@ skipping 147 matching lines @@
       // TODO(sky): having to use a replaceable url is a bit of a hack here.
       GURL instant_url(
           template_url->instant_url()->ReplaceSearchTerms(
               *template_url, std::wstring(), -1, std::wstring()));
       CommandLine* cl = CommandLine::ForCurrentProcess();
       if (cl->HasSwitch(switches::kInstantURL))
         instant_url = GURL(cl->GetSwitchValueASCII(switches::kInstantURL));
       preview_contents_->controller().LoadURL(
           instant_url, GURL(), transition_type);
       frame_load_observer_.reset(
-          new FrameLoadObserver(preview_contents()->tab_contents(),
-                                user_text_, verbatim));
+          new FrameLoadObserver(this,
+                                preview_contents()->tab_contents(),
+                                user_text_,
+                                verbatim));
     }
   } else {
     DCHECK(template_url_id_ == 0);
     frame_load_observer_.reset(NULL);
     preview_contents_->controller().LoadURL(url_, GURL(), transition_type);
   }
 }
 
 void InstantLoader::SetOmniboxBounds(const gfx::Rect& bounds) {
   if (omnibox_bounds_ == bounds)
@@ skipping 135 matching lines @@
       delegate_->AddToBlacklist(this, load_details->entry->url());
     }
     return;
   }
 
   NOTREACHED() << "Got a notification we didn't register for.";
 }
 
 void InstantLoader::PageFinishedLoading() {
   frame_load_observer_.reset();
+
+  // Send the bounds of the omnibox down now.
+  SendBoundsToPage(false);
+
   // Wait for the user input before showing, this way the page should be up to
   // date by the time we show it.
 }
 
 // TODO(tonyg): This method only fires when the omnibox bounds change. It also
 // needs to fire when the preview bounds change (e.g. open/close info bar).
 gfx::Rect InstantLoader::GetOmniboxBoundsInTermsOfPreview() {
   gfx::Rect preview_bounds(delegate_->GetInstantBounds());
   gfx::Rect intersection(omnibox_bounds_.Intersect(preview_bounds));
 
@@ skipping 13 matching lines @@
   return intersection;
 }
 
 void InstantLoader::PageDoesntSupportInstant(bool needs_reload) {
   frame_load_observer_.reset(NULL);
 
   delegate_->InstantLoaderDoesntSupportInstant(this);
 }
 
 void InstantLoader::ProcessBoundsChange() {
+  SendBoundsToPage(false);
+}
+
+void InstantLoader::SendBoundsToPage(bool force_if_waiting) {
   if (last_omnibox_bounds_ == omnibox_bounds_)
     return;
 
-  last_omnibox_bounds_ = omnibox_bounds_;
   if (preview_contents_.get() && is_showing_instant() &&
-      !is_waiting_for_load()) {
+      (force_if_waiting || !is_waiting_for_load())) {
+    last_omnibox_bounds_ = omnibox_bounds_;
     preview_contents_->render_view_host()->SearchBoxResize(
         GetOmniboxBoundsInTermsOfPreview());
   }
 }
 
 void InstantLoader::CreatePreviewContents(TabContentsWrapper* tab_contents) {
   TabContents* new_contents =
       new TabContents(
           tab_contents->profile(), NULL, MSG_ROUTING_NONE, NULL, NULL);
   preview_contents_.reset(new TabContentsWrapper(new_contents));
@@ skipping 25 matching lines @@
       Source<NavigationController>(&preview_contents_->controller()));
 #endif
 
   registrar_.Add(
       this,
       NotificationType::NAV_ENTRY_COMMITTED,
       Source<NavigationController>(&preview_contents_->controller()));
 
   preview_contents_->tab_contents()->ShowContents();
 }