Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(287)

Unified Diff: chrome/browser/instant/instant_page.h

Issue 11824050: InstantExtended: Committed NTP (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Address comments. Created 7 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: chrome/browser/instant/instant_page.h
diff --git a/chrome/browser/instant/instant_page.h b/chrome/browser/instant/instant_page.h
new file mode 100644
index 0000000000000000000000000000000000000000..a8a988ebf12a3f4862ae726bfa2bca66c128ce33
--- /dev/null
+++ b/chrome/browser/instant/instant_page.h
@@ -0,0 +1,214 @@
+// Copyright 2013 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_PAGE_H_
+#define CHROME_BROWSER_INSTANT_INSTANT_PAGE_H_
+
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/string16.h"
+#include "chrome/common/instant_types.h"
+#include "content/public/browser/web_contents_observer.h"
+#include "content/public/common/page_transition_types.h"
+
+namespace chrome {
+namespace search {
+struct Mode;
+}
+}
+
+namespace content {
+class WebContents;
+}
+
+namespace gfx {
+class Rect;
+}
+
+class GURL;
sreeram 2013/01/29 13:35:42 Chrome style is to put unnamespaced declarations f
samarth 2013/01/31 16:24:57 Done.
+
+// InstantPage is used to exchange messages with a page that implements the
+// Instant/Embedded Search API (http://dev.chromium.org/embeddedsearch).
+// InstantPage is not used directly but via one of its derived classes:
+// InstantOverlay, InstantNTP and InstantTab.
+class InstantPage : public content::WebContentsObserver {
+ public:
+ // InstantPage calls its delegate in response to messages received from the
+ // page. Each method is called with the |contents| corresponding to the page
+ // we are observing.
+ class Delegate {
+ public:
+ // Called upon determination of Instant API support. Either in response to
+ // the page loading or because we receivied some other message.
sreeram 2013/01/29 13:35:42 receivied -> received
samarth 2013/01/31 16:24:57 Done.
+ virtual void InstantSupportDetermined(const content::WebContents* contents,
+ bool supports_instant) = 0;
+
+ // Called when the underlying RenderView crashed.
+ virtual void InstantPageRenderViewGone(
+ const content::WebContents* contents) = 0;
+
+ // Called when the page is about to navigate to |url|.
+ virtual void InstantPageAboutToNavigateMainFrame(
+ const content::WebContents* contents,
+ const GURL& url) = 0;
+
+ // Called when the page has suggestions. Usually in response to Update(),
+ // SendAutocompleteResults() or UpOrDownKeyPressed().
+ virtual void SetSuggestions(
+ const content::WebContents* contents,
+ const std::vector<InstantSuggestion>& suggestions) = 0;
+
+ // Called when the page wants to be shown. Usually in response to Update(),
+ // SendAutocompleteResults() or SearchModeChanged().
+ virtual void ShowInstantPreview(const content::WebContents* contents,
+ InstantShownReason reason,
+ int height,
+ InstantSizeUnits units) = 0;
+
+ // Called when the page wants the omnibox to start capturing user key
+ // strokes. If this call is processed successfully, the omnibox will not
+ // look focused visibly but any user key strokes will go to the omnibox.
+ // Currently, this is implemented by focusing the omnibox invisibly.
+ virtual void StartCapturingKeyStrokes(
+ const content::WebContents* contents) = 0;
+
+ // Called when the page wants the omnibox to stop capturing user key
+ // strokes.
+ virtual void StopCapturingKeyStrokes(content::WebContents* contents) = 0;
+
+ // Called when the page wants to navigate to the specified URL. Usually
+ // used by the page to navigate to privileged destinations (e.g. chrome://
+ // URLs) or to navigate to URLs that are hidden from the page using
+ // Restricted IDs (rid in the API).
+ virtual void NavigateToURL(const content::WebContents* contents,
+ const GURL& url,
+ content::PageTransition transition) = 0;
+
+ protected:
+ virtual ~Delegate();
+ };
+
+ virtual ~InstantPage();
+
+ // The WebContents corresponding to the page we're talking to. May be NULL.
+ content::WebContents* contents() const { return contents_; }
+
+ // Returns true if the page is known to support the Instant API. This starts
+ // out false, and is set to true whenever we get any message from the page.
+ // Once true, it never becomes false (the page isn't expected to drop API
+ // support suddenly).
+ bool supports_instant() const { return supports_instant_; }
+
+ // Tells the page that the user typed |text| into the omnibox. If |verbatim|
+ // is false, the page predicts the query the user means to type and fetches
+ // results for the prediction. If |verbatim| is true, |text| is taken as the
+ // exact query (no prediction is made).
+ virtual void Update(const string16& text,
+ size_t selection_start,
+ size_t selection_end,
+ bool verbatim);
+
+ // Tells the page that the user pressed Enter in the omnibox.
+ void Submit(const string16& text);
+
+ // Tells the page that the user clicked on it. Nothing is being cancelled; the
+ // poor choice of name merely reflects the IPC of the same (poor) name.
+ void Cancel(const string16& text);
+
+ // Tells the page the bounds of the omnibox dropdown (in screen coordinates).
+ // This is used by the page to offset the results to avoid them being covered
+ // by the omnibox dropdown.
+ void SetPopupBounds(const gfx::Rect& bounds);
+
+ // Tells the page the start and end margins of the omnibox (in screen
+ // coordinates). This is used by the page to align text or assets properly
+ // with the omnibox.
+ void SetMarginSize(int start, int end);
+
+ // Tells the renderer to determine if the page supports the Instant API, which
+ // results in a call to InstantSupportDetermined() when the reply is received.
+ void DetermineIfPageSupportsInstant();
+
+ // Tells the page about the available autocomplete results.
+ void SendAutocompleteResults(
+ const std::vector<InstantAutocompleteResult>& results);
+
+ // Tells the page that the user pressed Up or Down in the omnibox. |count| is
+ // a repeat count, negative for moving up, positive for moving down.
+ void UpOrDownKeyPressed(int count);
+
+ // Tells the page that the active tab's search mode has changed.
+ void SearchModeChanged(const chrome::search::Mode& mode);
+
+ // Tells the page about the current theme background.
+ void SendThemeBackgroundInfo(const ThemeBackgroundInfo& theme_info);
+
+ // Tells the page about the current theme area height.
+ void SendThemeAreaHeight(int height);
+
+ // Tells the page whether it is allowed to display Instant results.
+ void SetDisplayInstantResults(bool display_instant_results);
+
+ // Tells the page whether the browser is capturing user key strokes.
+ void KeyCaptureChanged(bool is_key_capture_enabled);
+
+ protected:
+ explicit InstantPage(Delegate* delegate);
+
+ // Sets |contents| as the page to communicate with. |contents| may be NULL,
+ // which effectively stops all communication.
+ void SetContents(content::WebContents* contents);
+
+ Delegate* delegate() const { return delegate_; }
+
+ // These functions are called before processing messages received from the
+ // page. By default, all messages are handled, but any derived classes may
+ // choose to ingore some or all of the received messages by overriding these
+ // methods.
+ virtual bool ShouldProcessRenderViewGone() const;
+ virtual bool ShouldProcessAboutToNavigateMainFrame() const;
+ virtual bool ShouldProcessSetSuggestions() const;
+ virtual bool ShouldProcessShowInstantPreview() const;
+ virtual bool ShouldProcessStartCapturingKeyStrokes() const;
+ virtual bool ShouldProcessStopCapturingKeyStrokes() const;
+ virtual bool ShouldProcessNavigateToURL() const;
sreeram 2013/01/29 13:35:42 No, there's nothing inherently const about "Should
samarth 2013/01/31 16:24:57 Ok, done.
+
+ private:
+ // Overridden from content::WebContentsObserver:
+ virtual void DidFinishLoad(
+ int64 frame_id,
+ const GURL& validated_url,
+ bool is_main_frame,
+ content::RenderViewHost* render_view_host) OVERRIDE;
+ virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+ virtual void RenderViewGone(base::TerminationStatus status) OVERRIDE;
+ virtual void DidCommitProvisionalLoadForFrame(
+ int64 frame_id,
+ bool is_main_frame,
+ const GURL& url,
+ content::PageTransition transition_type,
+ content::RenderViewHost* render_view_host) OVERRIDE;
+
+ void OnSetSuggestions(int page_id,
+ const std::vector<InstantSuggestion>& suggestions);
+ void OnInstantSupportDetermined(int page_id, bool supports_instant);
+ void OnShowInstantPreview(int page_id,
+ InstantShownReason reason,
+ int height,
+ InstantSizeUnits units);
+ void OnStartCapturingKeyStrokes(int page_id);
+ void OnStopCapturingKeyStrokes(int page_id);
+ void OnSearchBoxNavigate(int page_id, const GURL& url,
+ content::PageTransition transition);
+
+ Delegate* const delegate_;
+ content::WebContents* contents_;
+ bool supports_instant_;
+
+ DISALLOW_COPY_AND_ASSIGN(InstantPage);
+};
+
+#endif // CHROME_BROWSER_INSTANT_INSTANT_PAGE_H_

Powered by Google App Engine
This is Rietveld 408576698