OLD | NEW |
(Empty) | |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #ifndef CHROME_BROWSER_INSTANT_INSTANT_PAGE_H_ |
| 6 #define CHROME_BROWSER_INSTANT_INSTANT_PAGE_H_ |
| 7 |
| 8 #include <vector> |
| 9 |
| 10 #include "base/basictypes.h" |
| 11 #include "base/compiler_specific.h" |
| 12 #include "base/string16.h" |
| 13 #include "chrome/common/instant_types.h" |
| 14 #include "content/public/browser/web_contents_observer.h" |
| 15 #include "content/public/common/page_transition_types.h" |
| 16 |
| 17 namespace chrome { |
| 18 namespace search { |
| 19 struct Mode; |
| 20 } |
| 21 } |
| 22 |
| 23 namespace content { |
| 24 class WebContents; |
| 25 } |
| 26 |
| 27 namespace gfx { |
| 28 class Rect; |
| 29 } |
| 30 |
| 31 class GURL; |
| 32 |
| 33 // InstantPage is used to exchange messages with a page that implements the |
| 34 // Instant/Embedded Search API (http://dev.chromium.org/embeddedsearch). |
| 35 // InstantPage is not used directly but via one of its derived classes: |
| 36 // InstantOverlay, InstantNTP and InstantTab. |
| 37 class InstantPage : public content::WebContentsObserver { |
| 38 public: |
| 39 // InstantPage calls its delegate in response to messages received from the |
| 40 // page. Each method is called with the |contents| corresponding to the page |
| 41 // we are observing. |
| 42 class Delegate { |
| 43 public: |
| 44 // Called upon determination of Instant API support. Either in response to |
| 45 // the page loading or because we receivied some other message. |
| 46 virtual void InstantSupportDetermined(const content::WebContents* contents, |
| 47 bool supports_instant) = 0; |
| 48 |
| 49 // Called when the underlying RenderView crashed. |
| 50 virtual void InstantPageRenderViewGone( |
| 51 const content::WebContents* contents) = 0; |
| 52 |
| 53 // Called when the page is about to navigate to |url|. |
| 54 virtual void InstantPageAboutToNavigateMainFrame( |
| 55 const content::WebContents* contents, |
| 56 const GURL& url) = 0; |
| 57 |
| 58 // Called when the page has suggestions. Usually in response to Update(), |
| 59 // SendAutocompleteResults() or UpOrDownKeyPressed(). |
| 60 virtual void SetSuggestions( |
| 61 const content::WebContents* contents, |
| 62 const std::vector<InstantSuggestion>& suggestions) = 0; |
| 63 |
| 64 // Called when the page wants to be shown. Usually in response to Update(), |
| 65 // SendAutocompleteResults() or SearchModeChanged(). |
| 66 virtual void ShowInstantPreview(const content::WebContents* contents, |
| 67 InstantShownReason reason, |
| 68 int height, |
| 69 InstantSizeUnits units) = 0; |
| 70 |
| 71 // Called when the page wants the omnibox to start capturing user key |
| 72 // strokes. If this call is processed successfully, the omnibox will not |
| 73 // look focused visibly but any user key strokes will go to the omnibox. |
| 74 // Currently, this is implemented by focusing the omnibox invisibly. |
| 75 virtual void StartCapturingKeyStrokes( |
| 76 const content::WebContents* contents) = 0; |
| 77 |
| 78 // Called when the page wants the omnibox to stop capturing user key |
| 79 // strokes. |
| 80 virtual void StopCapturingKeyStrokes(content::WebContents* contents) = 0; |
| 81 |
| 82 // Called when the page wants to navigate to the specified URL. Usually |
| 83 // used by the page to navigate to privileged destinations (e.g. chrome:// |
| 84 // URLs) or to navigate to URLs that are hidden from the page using |
| 85 // Restricted IDs (rid in the API). |
| 86 virtual void NavigateToURL(const content::WebContents* contents, |
| 87 const GURL& url, |
| 88 content::PageTransition transition) = 0; |
| 89 |
| 90 protected: |
| 91 virtual ~Delegate(); |
| 92 }; |
| 93 |
| 94 virtual ~InstantPage(); |
| 95 |
| 96 // The WebContents corresponding to the page we're talking to. May be NULL. |
| 97 content::WebContents* contents() const { return contents_; } |
| 98 |
| 99 // Returns true if the page is known to support the Instant API. This starts |
| 100 // out false, and is set to true whenever we get any message from the page. |
| 101 // Once true, it never becomes false (the page isn't expected to drop API |
| 102 // support suddenly). |
| 103 bool supports_instant() const { return supports_instant_; } |
| 104 |
| 105 // Tells the page that the user typed |text| into the omnibox. If |verbatim| |
| 106 // is false, the page predicts the query the user means to type and fetches |
| 107 // results for the prediction. If |verbatim| is true, |text| is taken as the |
| 108 // exact query (no prediction is made). |
| 109 virtual void Update(const string16& text, |
| 110 size_t selection_start, |
| 111 size_t selection_end, |
| 112 bool verbatim); |
| 113 |
| 114 // Tells the page that the user pressed Enter in the omnibox. |
| 115 void Submit(const string16& text); |
| 116 |
| 117 // Tells the page that the user clicked on it. Nothing is being cancelled; the |
| 118 // poor choice of name merely reflects the IPC of the same (poor) name. |
| 119 void Cancel(const string16& text); |
| 120 |
| 121 // Tells the page the bounds of the omnibox dropdown (in screen coordinates). |
| 122 // This is used by the page to offset the results to avoid them being covered |
| 123 // by the omnibox dropdown. |
| 124 void SetPopupBounds(const gfx::Rect& bounds); |
| 125 |
| 126 // Tells the page the start and end margins of the omnibox (in screen |
| 127 // coordinates). This is used by the page to align text or assets properly |
| 128 // with the omnibox. |
| 129 void SetMarginSize(int start, int end); |
| 130 |
| 131 // Tells the renderer to determine if the page supports the Instant API, which |
| 132 // results in a call to InstantSupportDetermined() when the reply is received. |
| 133 void DetermineIfPageSupportsInstant(); |
| 134 |
| 135 // Tells the page about the available autocomplete results. |
| 136 void SendAutocompleteResults( |
| 137 const std::vector<InstantAutocompleteResult>& results); |
| 138 |
| 139 // Tells the page that the user pressed Up or Down in the omnibox. |count| is |
| 140 // a repeat count, negative for moving up, positive for moving down. |
| 141 void UpOrDownKeyPressed(int count); |
| 142 |
| 143 // Tells the page that the active tab's search mode has changed. |
| 144 void SearchModeChanged(const chrome::search::Mode& mode); |
| 145 |
| 146 // Tells the page about the current theme background. |
| 147 void SendThemeBackgroundInfo(const ThemeBackgroundInfo& theme_info); |
| 148 |
| 149 // Tells the page about the current theme area height. |
| 150 void SendThemeAreaHeight(int height); |
| 151 |
| 152 // Tells the page whether it is allowed to display Instant results. |
| 153 void SetDisplayInstantResults(bool display_instant_results); |
| 154 |
| 155 // Tells the page whether the browser is capturing user key strokes. |
| 156 void KeyCaptureChanged(bool is_key_capture_enabled); |
| 157 |
| 158 protected: |
| 159 explicit InstantPage(Delegate* delegate); |
| 160 |
| 161 // Sets |contents| as the page to communicate with. |contents| may be NULL, |
| 162 // which effectively stops all communication. |
| 163 void SetContents(content::WebContents* contents); |
| 164 |
| 165 Delegate* delegate() const { return delegate_; } |
| 166 |
| 167 // These functions are called before processing messages received from the |
| 168 // page. By default, all messages are handled, but any derived classes may |
| 169 // choose to ingore some or all of the received messages by overriding these |
| 170 // methods. |
| 171 virtual bool ShouldProcessRenderViewGone() const; |
| 172 virtual bool ShouldProcessAboutToNavigateMainFrame() const; |
| 173 virtual bool ShouldProcessSetSuggestions() const; |
| 174 virtual bool ShouldProcessShowInstantPreview() const; |
| 175 virtual bool ShouldProcessStartCapturingKeyStrokes() const; |
| 176 virtual bool ShouldProcessStopCapturingKeyStrokes() const; |
| 177 virtual bool ShouldProcessNavigateToURL() const; |
| 178 |
| 179 private: |
| 180 // Overridden from content::WebContentsObserver: |
| 181 virtual void DidFinishLoad( |
| 182 int64 frame_id, |
| 183 const GURL& validated_url, |
| 184 bool is_main_frame, |
| 185 content::RenderViewHost* render_view_host) OVERRIDE; |
| 186 virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE; |
| 187 virtual void RenderViewGone(base::TerminationStatus status) OVERRIDE; |
| 188 virtual void DidCommitProvisionalLoadForFrame( |
| 189 int64 frame_id, |
| 190 bool is_main_frame, |
| 191 const GURL& url, |
| 192 content::PageTransition transition_type, |
| 193 content::RenderViewHost* render_view_host) OVERRIDE; |
| 194 |
| 195 void OnSetSuggestions(int page_id, |
| 196 const std::vector<InstantSuggestion>& suggestions); |
| 197 void OnInstantSupportDetermined(int page_id, bool supports_instant); |
| 198 void OnShowInstantPreview(int page_id, |
| 199 InstantShownReason reason, |
| 200 int height, |
| 201 InstantSizeUnits units); |
| 202 void OnStartCapturingKeyStrokes(int page_id); |
| 203 void OnStopCapturingKeyStrokes(int page_id); |
| 204 void OnSearchBoxNavigate(int page_id, const GURL& url, |
| 205 content::PageTransition transition); |
| 206 |
| 207 Delegate* const delegate_; |
| 208 content::WebContents* contents_; |
| 209 bool supports_instant_; |
| 210 }; |
| 211 |
| 212 #endif // CHROME_BROWSER_INSTANT_INSTANT_PAGE_H_ |
OLD | NEW |