Home | History | Annotate | Download | only in search 
      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 #include "chrome/browser/ui/search/search_ipc_router.h"
      6 
      7 #include "chrome/browser/search/search.h"
      8 #include "chrome/common/render_messages.h"
      9 #include "content/public/browser/web_contents.h"
     10 
     11 SearchIPCRouter::SearchIPCRouter(content::WebContents* web_contents,
     12                                  Delegate* delegate, scoped_ptr<Policy> policy)
     13     : WebContentsObserver(web_contents),
     14       delegate_(delegate),
     15       policy_(policy.Pass()),
     16       is_active_tab_(false) {
     17   DCHECK(web_contents);
     18   DCHECK(delegate);
     19   DCHECK(policy_.get());
     20 }
     21 
     22 SearchIPCRouter::~SearchIPCRouter() {}
     23 
     24 void SearchIPCRouter::DetermineIfPageSupportsInstant() {
     25   Send(new ChromeViewMsg_DetermineIfPageSupportsInstant(routing_id()));
     26 }
     27 
     28 void SearchIPCRouter::SendChromeIdentityCheckResult(
     29     const base::string16& identity,
     30     bool identity_match) {
     31   if (!policy_->ShouldProcessChromeIdentityCheck())
     32     return;
     33 
     34   Send(new ChromeViewMsg_ChromeIdentityCheckResult(routing_id(), identity,
     35                                                    identity_match));
     36 }
     37 
     38 void SearchIPCRouter::SetPromoInformation(bool is_app_launcher_enabled) {
     39   if (!policy_->ShouldSendSetPromoInformation())
     40     return;
     41 
     42   Send(new ChromeViewMsg_SearchBoxPromoInformation(routing_id(),
     43                                                    is_app_launcher_enabled));
     44 }
     45 
     46 void SearchIPCRouter::SetDisplayInstantResults() {
     47   if (!policy_->ShouldSendSetDisplayInstantResults())
     48     return;
     49 
     50   bool is_search_results_page = !chrome::GetSearchTerms(web_contents()).empty();
     51   Send(new ChromeViewMsg_SearchBoxSetDisplayInstantResults(
     52        routing_id(),
     53        (is_search_results_page && chrome::ShouldPrefetchSearchResultsOnSRP()) ||
     54        chrome::ShouldPrefetchSearchResults()));
     55 }
     56 
     57 void SearchIPCRouter::SetSuggestionToPrefetch(
     58     const InstantSuggestion& suggestion) {
     59   if (!policy_->ShouldSendSetSuggestionToPrefetch())
     60     return;
     61 
     62   Send(new ChromeViewMsg_SearchBoxSetSuggestionToPrefetch(routing_id(),
     63                                                           suggestion));
     64 }
     65 
     66 void SearchIPCRouter::SendMostVisitedItems(
     67     const std::vector<InstantMostVisitedItem>& items) {
     68   if (!policy_->ShouldSendMostVisitedItems())
     69     return;
     70 
     71   Send(new ChromeViewMsg_SearchBoxMostVisitedItemsChanged(routing_id(), items));
     72 }
     73 
     74 void SearchIPCRouter::SendThemeBackgroundInfo(
     75     const ThemeBackgroundInfo& theme_info) {
     76   if (!policy_->ShouldSendThemeBackgroundInfo())
     77     return;
     78 
     79   Send(new ChromeViewMsg_SearchBoxThemeChanged(routing_id(), theme_info));
     80 }
     81 
     82 void SearchIPCRouter::ToggleVoiceSearch() {
     83   if (!policy_->ShouldSendToggleVoiceSearch())
     84     return;
     85 
     86   Send(new ChromeViewMsg_SearchBoxToggleVoiceSearch(routing_id()));
     87 }
     88 
     89 void SearchIPCRouter::Submit(const base::string16& text) {
     90   if (!policy_->ShouldSubmitQuery())
     91     return;
     92 
     93   Send(new ChromeViewMsg_SearchBoxSubmit(routing_id(), text));
     94 }
     95 
     96 void SearchIPCRouter::OnTabActivated() {
     97   is_active_tab_ = true;
     98 }
     99 
    100 void SearchIPCRouter::OnTabDeactivated() {
    101   is_active_tab_ = false;
    102 }
    103 
    104 bool SearchIPCRouter::OnMessageReceived(const IPC::Message& message) {
    105   bool handled = true;
    106   IPC_BEGIN_MESSAGE_MAP(SearchIPCRouter, message)
    107     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_InstantSupportDetermined,
    108                         OnInstantSupportDetermined)
    109     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_SetVoiceSearchSupported,
    110                         OnVoiceSearchSupportDetermined)
    111     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_FocusOmnibox, OnFocusOmnibox);
    112     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_SearchBoxNavigate,
    113                         OnSearchBoxNavigate);
    114     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_SearchBoxDeleteMostVisitedItem,
    115                         OnDeleteMostVisitedItem);
    116     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_SearchBoxUndoMostVisitedDeletion,
    117                         OnUndoMostVisitedDeletion);
    118     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_SearchBoxUndoAllMostVisitedDeletions,
    119                         OnUndoAllMostVisitedDeletions);
    120     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_LogEvent, OnLogEvent);
    121     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_LogImpression, OnLogImpression);
    122     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_PasteAndOpenDropdown,
    123                         OnPasteAndOpenDropDown);
    124     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_ChromeIdentityCheck,
    125                         OnChromeIdentityCheck);
    126     IPC_MESSAGE_UNHANDLED(handled = false)
    127   IPC_END_MESSAGE_MAP()
    128   return handled;
    129 }
    130 
    131 void SearchIPCRouter::OnInstantSupportDetermined(int page_id,
    132                                                  bool instant_support) const {
    133   if (!web_contents()->IsActiveEntry(page_id))
    134     return;
    135 
    136   delegate_->OnInstantSupportDetermined(instant_support);
    137 }
    138 
    139 void SearchIPCRouter::OnVoiceSearchSupportDetermined(
    140     int page_id,
    141     bool supports_voice_search) const {
    142   if (!web_contents()->IsActiveEntry(page_id))
    143     return;
    144 
    145   delegate_->OnInstantSupportDetermined(true);
    146   if (!policy_->ShouldProcessSetVoiceSearchSupport())
    147     return;
    148 
    149   delegate_->OnSetVoiceSearchSupport(supports_voice_search);
    150 }
    151 
    152 void SearchIPCRouter::OnFocusOmnibox(int page_id,
    153                                      OmniboxFocusState state) const {
    154   if (!web_contents()->IsActiveEntry(page_id))
    155     return;
    156 
    157   delegate_->OnInstantSupportDetermined(true);
    158   if (!policy_->ShouldProcessFocusOmnibox(is_active_tab_))
    159     return;
    160 
    161   delegate_->FocusOmnibox(state);
    162 }
    163 
    164 void SearchIPCRouter::OnSearchBoxNavigate(
    165     int page_id,
    166     const GURL& url,
    167     WindowOpenDisposition disposition,
    168     bool is_most_visited_item_url) const {
    169   if (!web_contents()->IsActiveEntry(page_id))
    170     return;
    171 
    172   delegate_->OnInstantSupportDetermined(true);
    173   if (!policy_->ShouldProcessNavigateToURL(is_active_tab_))
    174     return;
    175 
    176   delegate_->NavigateToURL(url, disposition, is_most_visited_item_url);
    177 }
    178 
    179 void SearchIPCRouter::OnDeleteMostVisitedItem(int page_id,
    180                                               const GURL& url) const {
    181   if (!web_contents()->IsActiveEntry(page_id))
    182     return;
    183 
    184   delegate_->OnInstantSupportDetermined(true);
    185   if (!policy_->ShouldProcessDeleteMostVisitedItem())
    186     return;
    187 
    188   delegate_->OnDeleteMostVisitedItem(url);
    189 }
    190 
    191 void SearchIPCRouter::OnUndoMostVisitedDeletion(int page_id,
    192                                                 const GURL& url) const {
    193   if (!web_contents()->IsActiveEntry(page_id))
    194     return;
    195 
    196   delegate_->OnInstantSupportDetermined(true);
    197   if (!policy_->ShouldProcessUndoMostVisitedDeletion())
    198     return;
    199 
    200   delegate_->OnUndoMostVisitedDeletion(url);
    201 }
    202 
    203 void SearchIPCRouter::OnUndoAllMostVisitedDeletions(int page_id) const {
    204   if (!web_contents()->IsActiveEntry(page_id))
    205     return;
    206 
    207   delegate_->OnInstantSupportDetermined(true);
    208   if (!policy_->ShouldProcessUndoAllMostVisitedDeletions())
    209     return;
    210 
    211   delegate_->OnUndoAllMostVisitedDeletions();
    212 }
    213 
    214 void SearchIPCRouter::OnLogEvent(int page_id, NTPLoggingEventType event) const {
    215   if (!web_contents()->IsActiveEntry(page_id))
    216     return;
    217 
    218   delegate_->OnInstantSupportDetermined(true);
    219   if (!policy_->ShouldProcessLogEvent())
    220     return;
    221 
    222   delegate_->OnLogEvent(event);
    223 }
    224 
    225 void SearchIPCRouter::OnLogImpression(int page_id,
    226                                       int position,
    227                                       const base::string16& provider) const {
    228   if (!web_contents()->IsActiveEntry(page_id))
    229     return;
    230 
    231   // Only allow string of 8 alphanumeric characters or less as providers.
    232   if (provider.length() > 8)
    233     return;
    234   for (base::string16::const_iterator it = provider.begin();
    235        it != provider.end(); ++it) {
    236     if (!IsAsciiAlpha(*it) && !IsAsciiDigit(*it))
    237       return;
    238   }
    239 
    240   delegate_->OnInstantSupportDetermined(true);
    241   // Logging impressions is controlled by the same policy as logging events.
    242   if (!policy_->ShouldProcessLogEvent())
    243     return;
    244 
    245   delegate_->OnLogImpression(position, provider);
    246 }
    247 
    248 void SearchIPCRouter::OnPasteAndOpenDropDown(int page_id,
    249                                              const base::string16& text) const {
    250   if (!web_contents()->IsActiveEntry(page_id))
    251     return;
    252 
    253   delegate_->OnInstantSupportDetermined(true);
    254   if (!policy_->ShouldProcessPasteIntoOmnibox(is_active_tab_))
    255     return;
    256 
    257   delegate_->PasteIntoOmnibox(text);
    258 }
    259 
    260 void SearchIPCRouter::OnChromeIdentityCheck(
    261     int page_id,
    262     const base::string16& identity) const {
    263   if (!web_contents()->IsActiveEntry(page_id))
    264     return;
    265 
    266   delegate_->OnInstantSupportDetermined(true);
    267   if (!policy_->ShouldProcessChromeIdentityCheck())
    268     return;
    269 
    270   delegate_->OnChromeIdentityCheck(identity);
    271 }
    272 
    273 void SearchIPCRouter::set_delegate(Delegate* delegate) {
    274   DCHECK(delegate);
    275   delegate_ = delegate;
    276 }
    277 
    278 void SearchIPCRouter::set_policy(scoped_ptr<Policy> policy) {
    279   DCHECK(policy.get());
    280   policy_.reset(policy.release());
    281 }
    282