Remove unused / unnecessary stuff from Instant.

chrome/browser/instant/instant_controller.h

 // 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.
 
 #ifndef CHROME_BROWSER_INSTANT_INSTANT_CONTROLLER_H_
 #define CHROME_BROWSER_INSTANT_INSTANT_CONTROLLER_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/timer.h"
 #include "chrome/browser/instant/instant_commit_type.h"
-#include "chrome/browser/instant/instant_loader_delegate.h"
 #include "chrome/browser/instant/instant_model.h"
 #include "chrome/common/instant_types.h"
 #include "content/public/common/page_transition_types.h"
 #include "googleurl/src/gurl.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/rect.h"
 
 struct AutocompleteMatch;
 class AutocompleteProvider;
-class InstantControllerDelegate;
 class InstantLoader;
 class PrefService;
 class Profile;
 class TabContents;
 class TemplateURL;
 
+namespace chrome {
+class BrowserInstantController;
+}
+
 // InstantController maintains a WebContents that is intended to give a
 // preview of search results. InstantController is owned by Browser via
 // BrowserInstantController.
 //
 // At any time the WebContents maintained by InstantController may be hidden
 // from view by way of Hide(), which may result in a change in the model's
-// display state and subsequent change in model observers. Similarly the preview
-// may be committed at any time by invoking CommitCurrentPreview(), which
-// results in CommitInstant() being invoked on the delegate.
-class InstantController : public InstantLoaderDelegate {
+// display state and subsequent change in model observers. Similarly, the
+// preview may be committed at any time by invoking CommitCurrentPreview(),
+// which results in CommitInstant() being invoked on the browser.
+class InstantController {
  public:
-  // Amount of time to wait before starting the animation for suggested text.
-  static const int kInlineAutocompletePauseTimeMS = 1000;
-
-  // Duration of the suggested text animation in which the colors change.
-  static const int kInlineAutocompleteFadeInTimeMS = 300;
-
   // InstantController may operate in one of these modes:
   //   EXTENDED: The default search engine is preloaded when the omnibox gets
   //       focus. Queries are issued as the user types. Predicted queries are
   //       inline autocompleted into the omnibox. Previews of search results
   //       as well as predicted URLs are shown. Search suggestions are rendered
   //       within the search results preview.
   //   INSTANT: Same as EXTENDED, without URL previews. Search suggestions are
   //       rendered by the omnibox drop down, and not by the preview page.
-  //   SUGGEST: Same as INSTANT, without visible previews.
-  //   HIDDEN: Same as SUGGEST, without the inline autocompletion.
-  //   SILENT: Same as HIDDEN, without issuing queries as the user types. The
-  //       query is sent only after the user presses <Enter>.
   //   DISABLED: Instant is disabled.
   enum Mode {
     EXTENDED,
     INSTANT,
-    SUGGEST,
-    HIDDEN,
-    SILENT,
     DISABLED,
   };
 
   virtual ~InstantController();
 
   // Creates a new InstantController. Caller owns the returned object. The
   // |profile| pointer is not cached, so the underlying profile object need not
   // live beyond this call. ***NOTE***: May return NULL, which means that
   // Instant is disabled in this profile.
-  static InstantController* CreateInstant(Profile* profile,
-                                          InstantControllerDelegate* delegate);
+  static InstantController* CreateInstant(
+      Profile* profile,
+      chrome::BrowserInstantController* browser);
 
   // Returns true if Instant is enabled and supports the extended API.
   static bool IsExtendedAPIEnabled(Profile* profile);
 
   // Returns true if Instant is enabled in a visible, preview-showing mode.
   static bool IsInstantEnabled(Profile* profile);
 
-  // Returns true if Instant will provide autocomplete suggestions.
-  static bool IsSuggestEnabled(Profile* profile);
-
   // Registers Instant related preferences.
   static void RegisterUserPrefs(PrefService* prefs);
 
   // Invoked as the user types into the omnibox. |user_text| is what the user
   // has typed. |full_text| is what the omnibox is showing. These may differ if
   // the user typed only some text, and the rest was inline autocompleted. If
   // |verbatim| is true, search results are shown for the exact omnibox text,
   // rather than the best guess as to what the user means. Returns true if the
   // update is accepted (i.e., if |match| is a search rather than a URL).
   bool Update(const AutocompleteMatch& match,
@@ skipping 20 matching lines @@
 
   // Hides the preview, but doesn't destroy it, in hopes it can be subsequently
   // reused. The preview will not be used until a call to Update() succeeds.
   void Hide();
 
   // Returns true if the Instant preview can be committed now. This can be true
   // even if the preview is not showing yet, because we can commit as long as
   // we've processed the last Update() and we know the loader supports Instant.
   bool IsCurrent() const;
 
-  // Commits the preview. Calls CommitInstant() on the delegate.
+  // Commits the preview. Calls CommitInstant() on the browser.
   void CommitCurrentPreview(InstantCommitType type);
 
   // The autocomplete edit that was initiating the current Instant session has
   // lost focus. Commit or discard the preview accordingly.
   void OnAutocompleteLostFocus(gfx::NativeView view_gaining_focus);
 
   // The autocomplete edit has gained focus. Preload the Instant URL of the
   // default search engine, in anticipation of the user typing a query.
   void OnAutocompleteGotFocus();
 
   // The active tab's "NTP status" has changed. Pass the message down to the
   // loader which will notify the renderer.
   void OnActiveTabModeChanged(bool active_tab_is_ntp);
 
   // Returns whether the preview will be committed when the mouse or touch
   // pointer is released.
   bool commit_on_pointer_release() const;
 
   // Returns the transition type of the last AutocompleteMatch passed to Update.
   content::PageTransition last_transition_type() const {
     return last_transition_type_;
   }
 
-  // InstantLoaderDelegate:
-  virtual void SetSuggestions(
-      InstantLoader* loader,
-      const std::vector<InstantSuggestion>& suggestions) OVERRIDE;
-  virtual void CommitInstantLoader(InstantLoader* loader) OVERRIDE;
-  virtual void ShowInstantPreview(InstantLoader* loader,
-                                  InstantShownReason reason,
-                                  int height,
-                                  InstantSizeUnits units) OVERRIDE;
-  virtual void InstantLoaderPreviewLoaded(InstantLoader* loader) OVERRIDE;
-  virtual void InstantSupportDetermined(InstantLoader* loader,
-                                        bool supports_instant) OVERRIDE;
-  virtual void SwappedTabContents(InstantLoader* loader) OVERRIDE;
-  virtual void InstantLoaderContentsFocused(InstantLoader* loader) OVERRIDE;
+  const InstantModel* model() const { return &model_; }
+
+  // Invoked by InstantLoader when it has suggested text.
+  void SetSuggestions(InstantLoader* loader,
+                      const std::vector<InstantSuggestion>& suggestions);
+
+  // Invoked by InstantLoader to commit the preview.
+  void CommitInstantLoader(InstantLoader* loader);
+
+  // Invoked by InstantLoader to request that the preview be shown.
+  void ShowInstantPreview(InstantLoader* loader,
+                          InstantShownReason reason,
+                          int height,
+                          InstantSizeUnits units);
+
+  // Invoked by InstantLoader to notify that the Instant URL completed loading.
+  void InstantLoaderPreviewLoaded(InstantLoader* loader);
+
+  // Invoked by InstantLoader when it has determined whether or not the page
+  // supports the Instant API.
+  void InstantSupportDetermined(InstantLoader* loader, bool supports_instant);
+
+  // Invoked by InstantLoader when it has swapped a different TabContents into
+  // the preview, usually because a prerendered page was navigated to.
+  void SwappedTabContents(InstantLoader* loader);
+
+  // Invoked by InstantLoader when the preview gains focus, usually due to the
+  // user clicking on it.
+  void InstantLoaderContentsFocused(InstantLoader* loader);
 
 #if defined(UNIT_TEST)
   // Accessors used only in tests.
   InstantLoader* loader() const { return loader_.get(); }
 #endif
 
-  const InstantModel* model() const { return &model_; }
-
  private:
   FRIEND_TEST_ALL_PREFIXES(InstantTest, InstantLoaderRefresh);
 
-  InstantController(InstantControllerDelegate* delegate, Mode mode);
+  InstantController(chrome::BrowserInstantController* browser, Mode mode);
 
   // Creates a new loader if necessary (for example, if the |instant_url| has
   // changed since the last time we created the loader).
   void ResetLoader(const std::string& instant_url,
                    const TabContents* active_tab);
 
   // Ensures that the |loader_| uses the default Instant URL, recreating it if
   // necessary, and returns true. Returns false if the Instant URL could not be
   // determined or the active tab is NULL (browser is shutting down).
   bool CreateDefaultLoader();
 
   // If the |loader_| is not showing, it is deleted and recreated. Else the
   // refresh is skipped and the next refresh is scheduled.
   void OnStaleLoader();
 
   // Calls OnStaleLoader if |stale_loader_timer_| is not running.
   void MaybeOnStaleLoader();
 
   // Destroys the |loader_| and its preview contents.
   void DeleteLoader();
 
-  // Counterpart to Hide(). Asks the |delegate_| to display the preview with
+  // Counterpart to Hide(). Asks the |browser_| to display the preview with
   // the given |height|.
   void Show(int height, InstantSizeUnits units);
 
   // Send the omnibox dropdown bounds to the page.
   void SendBoundsToPage();
 
   // If |template_url| is a valid TemplateURL for use with Instant, fills in
   // |instant_url| and returns true; returns false otherwise.
   // Note: If the command-line switch kInstantURL is set, this method uses its
   // value for |instant_url| and returns true without examining |template_url|.
   bool GetInstantURL(const TemplateURL* template_url,
                      const GURL& tab_url,
                      std::string* instant_url) const;
 
   // Returns true if the preview is no longer relevant, say because the last
   // Update() was for a URL and not a search query, or the user switched tabs.
   bool IsOutOfDate() const;
 
-  InstantControllerDelegate* const delegate_;
+  chrome::BrowserInstantController* const browser_;
 
   InstantModel model_;
 
   scoped_ptr<InstantLoader> loader_;
 
   // See the enum description above.
   const Mode mode_;
 
   // The active tab at the time of the last Update(). Used by IsOutOfDate() to
   // know whether the user switched tabs. ***NEVER DEREFERENCE THIS POINTER.***
@@ skipping 48 matching lines @@
   // the map at all or has a value 0, it means that search engine supports the
   // Instant API (or we assume it does, since we haven't determined it doesn't).
   std::map<std::string, int> blacklisted_urls_;
 
   // Search terms extraction (for autocomplete history matches) doesn't work
   // on Instant URLs. So, whenever the user commits an Instant search, we add
   // an equivalent non-Instant search URL to history, so that the search shows
   // up in autocomplete history matches.
   GURL url_for_history_;
 
-  DISALLOW_IMPLICIT_CONSTRUCTORS(InstantController);
+  DISALLOW_COPY_AND_ASSIGN(InstantController);
 };
 
 #endif  // CHROME_BROWSER_INSTANT_INSTANT_CONTROLLER_H_