ui/app_list/search_controller.cc

   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 "ui/app_list/search_controller.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/metrics/histogram_macros.h"
  13 #include "base/metrics/user_metrics.h"
  14 #include "base/strings/string_util.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "ui/app_list/app_list_constants.h"
  17 #include "ui/app_list/search/history.h"
  18 #include "ui/app_list/search_box_model.h"
  19 #include "ui/app_list/search_provider.h"
  20 #include "ui/app_list/search_result.h"
  21
  22 namespace {
  23
  24 // Maximum time (in milliseconds) to wait to the search providers to finish.
  25 const int kStopTimeMS = 1500;
  26 }
  27
  28 namespace app_list {
  29
  30 SearchController::SearchController(SearchBoxModel* search_box,
  31                                    AppListModel::SearchResults* results,
  32                                    History* history)
  33     : search_box_(search_box),
  34       dispatching_query_(false),
  35       mixer_(new Mixer(results)),
  36       history_(history),
  37       is_voice_query_(false) {
  38 }
  39
  40 SearchController::~SearchController() {
  41 }
  42
  43 void SearchController::Start(bool is_voice_query) {
  44   Stop();
  45
  46   base::string16 query;
  47   base::TrimWhitespace(search_box_->text(), base::TRIM_ALL, &query);
  48
  49   dispatching_query_ = true;
  50   for (Providers::iterator it = providers_.begin();
  51        it != providers_.end();
  52        ++it) {
  53     (*it)->Start(is_voice_query, query);
  54   }
  55   dispatching_query_ = false;
  56
  57   is_voice_query_ = is_voice_query;
  58
  59   OnResultsChanged();
  60
  61   stop_timer_.Start(FROM_HERE,
  62                     base::TimeDelta::FromMilliseconds(kStopTimeMS),
  63                     base::Bind(&SearchController::Stop,
  64                                base::Unretained(this)));
  65 }
  66
  67 void SearchController::Stop() {
  68   stop_timer_.Stop();
  69
  70   for (Providers::iterator it = providers_.begin();
  71        it != providers_.end();
  72        ++it) {
  73     (*it)->Stop();
  74   }
  75 }
  76
  77 void SearchController::OpenResult(SearchResult* result, int event_flags) {
  78   // Count AppList.Search here because it is composed of search + action.
  79   base::RecordAction(base::UserMetricsAction("AppList_Search"));
  80
  81   UMA_HISTOGRAM_ENUMERATION(kSearchResultOpenDisplayTypeHistogram,
  82                             result->display_type(),
  83                             SearchResult::DISPLAY_TYPE_LAST);
  84
  85   if (result->display_type() != SearchResult::DISPLAY_RECOMMENDATION) {
  86     UMA_HISTOGRAM_COUNTS_100(kSearchQueryLength, search_box_->text().size());
  87
  88     if (result->distance_from_origin() >= 0) {
  89       UMA_HISTOGRAM_COUNTS_100(kSearchResultDistanceFromOrigin,
  90                                result->distance_from_origin());
  91     }
  92   }
  93
  94   result->Open(event_flags);
  95
  96   if (history_ && history_->IsReady()) {
  97     history_->AddLaunchEvent(base::UTF16ToUTF8(search_box_->text()),
  98                              result->id());
  99   }
 100 }
 101
 102 void SearchController::InvokeResultAction(SearchResult* result,
 103                                           int action_index,
 104                                           int event_flags) {
 105   // TODO(xiyuan): Hook up with user learning.
 106   result->InvokeAction(action_index, event_flags);
 107 }
 108
 109 size_t SearchController::AddGroup(size_t max_results,
 110                                   double boost,
 111                                   double multiplier) {
 112   return mixer_->AddGroup(max_results, boost, multiplier);
 113 }
 114
 115 size_t SearchController::AddOmniboxGroup(size_t max_results,
 116                                          double boost,
 117                                          double multiplier) {
 118   return mixer_->AddOmniboxGroup(max_results, boost, multiplier);
 119 }
 120
 121 void SearchController::AddProvider(size_t group_id,
 122                                    scoped_ptr<SearchProvider> provider) {
 123   provider->set_result_changed_callback(base::Bind(
 124       &SearchController::OnResultsChanged,
 125       base::Unretained(this)));
 126   mixer_->AddProviderToGroup(group_id, provider.get());
 127   providers_.push_back(provider.Pass());
 128 }
 129
 130 void SearchController::OnResultsChanged() {
 131   if (dispatching_query_)
 132     return;
 133
 134   KnownResults known_results;
 135   if (history_ && history_->IsReady()) {
 136     history_->GetKnownResults(base::UTF16ToUTF8(search_box_->text()))
 137         ->swap(known_results);
 138   }
 139
 140   mixer_->MixAndPublish(is_voice_query_, known_results);
 141 }
 142
 143 }  // namespace app_list