chrome/browser/extensions/api/omnibox/omnibox_api.cc

   1 // Copyright (c) 2012 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/extensions/api/omnibox/omnibox_api.h"
   6
   7 #include "base/lazy_instance.h"
   8 #include "base/strings/string16.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "chrome/browser/extensions/tab_helper.h"
  11 #include "chrome/browser/profiles/profile.h"
  12 #include "chrome/browser/search_engines/template_url_service_factory.h"
  13 #include "chrome/common/extensions/api/omnibox.h"
  14 #include "chrome/common/extensions/api/omnibox/omnibox_handler.h"
  15 #include "components/search_engines/template_url.h"
  16 #include "components/search_engines/template_url_service.h"
  17 #include "content/public/browser/notification_details.h"
  18 #include "content/public/browser/notification_service.h"
  19 #include "extensions/browser/event_router.h"
  20 #include "extensions/browser/extension_prefs.h"
  21 #include "extensions/browser/extension_prefs_factory.h"
  22 #include "extensions/browser/extension_registry.h"
  23 #include "extensions/browser/notification_types.h"
  24 #include "ui/gfx/image/image.h"
  25
  26 namespace extensions {
  27
  28 namespace omnibox = api::omnibox;
  29 namespace SendSuggestions = omnibox::SendSuggestions;
  30 namespace SetDefaultSuggestion = omnibox::SetDefaultSuggestion;
  31
  32 namespace {
  33
  34 const char kSuggestionContent[] = "content";
  35 const char kCurrentTabDisposition[] = "currentTab";
  36 const char kForegroundTabDisposition[] = "newForegroundTab";
  37 const char kBackgroundTabDisposition[] = "newBackgroundTab";
  38
  39 // Pref key for omnibox.setDefaultSuggestion.
  40 const char kOmniboxDefaultSuggestion[] = "omnibox_default_suggestion";
  41
  42 #if defined(OS_LINUX)
  43 static const int kOmniboxIconPaddingLeft = 2;
  44 static const int kOmniboxIconPaddingRight = 2;
  45 #elif defined(OS_MACOSX)
  46 static const int kOmniboxIconPaddingLeft = 0;
  47 static const int kOmniboxIconPaddingRight = 2;
  48 #else
  49 static const int kOmniboxIconPaddingLeft = 0;
  50 static const int kOmniboxIconPaddingRight = 0;
  51 #endif
  52
  53 scoped_ptr<omnibox::SuggestResult> GetOmniboxDefaultSuggestion(
  54     Profile* profile,
  55     const std::string& extension_id) {
  56   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile);
  57
  58   scoped_ptr<omnibox::SuggestResult> suggestion;
  59   const base::DictionaryValue* dict = NULL;
  60   if (prefs && prefs->ReadPrefAsDictionary(extension_id,
  61                                            kOmniboxDefaultSuggestion,
  62                                            &dict)) {
  63     suggestion.reset(new omnibox::SuggestResult);
  64     omnibox::SuggestResult::Populate(*dict, suggestion.get());
  65   }
  66   return suggestion.Pass();
  67 }
  68
  69 // Tries to set the omnibox default suggestion; returns true on success or
  70 // false on failure.
  71 bool SetOmniboxDefaultSuggestion(
  72     Profile* profile,
  73     const std::string& extension_id,
  74     const omnibox::DefaultSuggestResult& suggestion) {
  75   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile);
  76   if (!prefs)
  77     return false;
  78
  79   scoped_ptr<base::DictionaryValue> dict = suggestion.ToValue();
  80   // Add the content field so that the dictionary can be used to populate an
  81   // omnibox::SuggestResult.
  82   dict->SetWithoutPathExpansion(kSuggestionContent, new base::StringValue(""));
  83   prefs->UpdateExtensionPref(extension_id,
  84                              kOmniboxDefaultSuggestion,
  85                              dict.release());
  86
  87   return true;
  88 }
  89
  90 // Returns a string used as a template URL string of the extension.
  91 std::string GetTemplateURLStringForExtension(const std::string& extension_id) {
  92   // This URL is not actually used for navigation. It holds the extension's ID.
  93   return std::string(extensions::kExtensionScheme) + "://" +
  94       extension_id + "/?q={searchTerms}";
  95 }
  96
  97 }  // namespace
  98
  99 // static
 100 void ExtensionOmniboxEventRouter::OnInputStarted(
 101     Profile* profile, const std::string& extension_id) {
 102   scoped_ptr<Event> event(new Event(
 103       omnibox::OnInputStarted::kEventName,
 104       make_scoped_ptr(new base::ListValue())));
 105   event->restrict_to_browser_context = profile;
 106   EventRouter::Get(profile)
 107       ->DispatchEventToExtension(extension_id, event.Pass());
 108 }
 109
 110 // static
 111 bool ExtensionOmniboxEventRouter::OnInputChanged(
 112     Profile* profile, const std::string& extension_id,
 113     const std::string& input, int suggest_id) {
 114   EventRouter* event_router = EventRouter::Get(profile);
 115   if (!event_router->ExtensionHasEventListener(
 116           extension_id, omnibox::OnInputChanged::kEventName))
 117     return false;
 118
 119   scoped_ptr<base::ListValue> args(new base::ListValue());
 120   args->Set(0, new base::StringValue(input));
 121   args->Set(1, new base::FundamentalValue(suggest_id));
 122
 123   scoped_ptr<Event> event(new Event(omnibox::OnInputChanged::kEventName,
 124                                     args.Pass()));
 125   event->restrict_to_browser_context = profile;
 126   event_router->DispatchEventToExtension(extension_id, event.Pass());
 127   return true;
 128 }
 129
 130 // static
 131 void ExtensionOmniboxEventRouter::OnInputEntered(
 132     content::WebContents* web_contents,
 133     const std::string& extension_id,
 134     const std::string& input,
 135     WindowOpenDisposition disposition) {
 136   Profile* profile =
 137       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 138
 139   const Extension* extension =
 140       ExtensionRegistry::Get(profile)->enabled_extensions().GetByID(
 141           extension_id);
 142   CHECK(extension);
 143   extensions::TabHelper::FromWebContents(web_contents)->
 144       active_tab_permission_granter()->GrantIfRequested(extension);
 145
 146   scoped_ptr<base::ListValue> args(new base::ListValue());
 147   args->Set(0, new base::StringValue(input));
 148   if (disposition == NEW_FOREGROUND_TAB)
 149     args->Set(1, new base::StringValue(kForegroundTabDisposition));
 150   else if (disposition == NEW_BACKGROUND_TAB)
 151     args->Set(1, new base::StringValue(kBackgroundTabDisposition));
 152   else
 153     args->Set(1, new base::StringValue(kCurrentTabDisposition));
 154
 155   scoped_ptr<Event> event(new Event(omnibox::OnInputEntered::kEventName,
 156                                     args.Pass()));
 157   event->restrict_to_browser_context = profile;
 158   EventRouter::Get(profile)
 159       ->DispatchEventToExtension(extension_id, event.Pass());
 160
 161   content::NotificationService::current()->Notify(
 162       extensions::NOTIFICATION_EXTENSION_OMNIBOX_INPUT_ENTERED,
 163       content::Source<Profile>(profile),
 164       content::NotificationService::NoDetails());
 165 }
 166
 167 // static
 168 void ExtensionOmniboxEventRouter::OnInputCancelled(
 169     Profile* profile, const std::string& extension_id) {
 170   scoped_ptr<Event> event(new Event(
 171       omnibox::OnInputCancelled::kEventName,
 172       make_scoped_ptr(new base::ListValue())));
 173   event->restrict_to_browser_context = profile;
 174   EventRouter::Get(profile)
 175       ->DispatchEventToExtension(extension_id, event.Pass());
 176 }
 177
 178 OmniboxAPI::OmniboxAPI(content::BrowserContext* context)
 179     : profile_(Profile::FromBrowserContext(context)),
 180       url_service_(TemplateURLServiceFactory::GetForProfile(profile_)),
 181       extension_registry_observer_(this) {
 182   extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
 183   if (url_service_) {
 184     template_url_sub_ = url_service_->RegisterOnLoadedCallback(
 185         base::Bind(&OmniboxAPI::OnTemplateURLsLoaded,
 186                    base::Unretained(this)));
 187   }
 188
 189   // Use monochrome icons for Omnibox icons.
 190   omnibox_popup_icon_manager_.set_monochrome(true);
 191   omnibox_icon_manager_.set_monochrome(true);
 192   omnibox_icon_manager_.set_padding(gfx::Insets(0, kOmniboxIconPaddingLeft,
 193                                                 0, kOmniboxIconPaddingRight));
 194 }
 195
 196 void OmniboxAPI::Shutdown() {
 197   template_url_sub_.reset();
 198 }
 199
 200 OmniboxAPI::~OmniboxAPI() {
 201 }
 202
 203 static base::LazyInstance<BrowserContextKeyedAPIFactory<OmniboxAPI> >
 204     g_factory = LAZY_INSTANCE_INITIALIZER;
 205
 206 // static
 207 BrowserContextKeyedAPIFactory<OmniboxAPI>* OmniboxAPI::GetFactoryInstance() {
 208   return g_factory.Pointer();
 209 }
 210
 211 // static
 212 OmniboxAPI* OmniboxAPI::Get(content::BrowserContext* context) {
 213   return BrowserContextKeyedAPIFactory<OmniboxAPI>::Get(context);
 214 }
 215
 216 void OmniboxAPI::OnExtensionLoaded(content::BrowserContext* browser_context,
 217                                    const Extension* extension) {
 218   const std::string& keyword = OmniboxInfo::GetKeyword(extension);
 219   if (!keyword.empty()) {
 220     // Load the omnibox icon so it will be ready to display in the URL bar.
 221     omnibox_popup_icon_manager_.LoadIcon(profile_, extension);
 222     omnibox_icon_manager_.LoadIcon(profile_, extension);
 223
 224     if (url_service_) {
 225       url_service_->Load();
 226       if (url_service_->loaded()) {
 227         url_service_->RegisterOmniboxKeyword(
 228             extension->id(), extension->name(), keyword,
 229             GetTemplateURLStringForExtension(extension->id()));
 230       } else {
 231         pending_extensions_.insert(extension);
 232       }
 233     }
 234   }
 235 }
 236
 237 void OmniboxAPI::OnExtensionUnloaded(content::BrowserContext* browser_context,
 238                                      const Extension* extension,
 239                                      UnloadedExtensionInfo::Reason reason) {
 240   if (!OmniboxInfo::GetKeyword(extension).empty() && url_service_) {
 241     if (url_service_->loaded()) {
 242       url_service_->RemoveExtensionControlledTURL(
 243           extension->id(), TemplateURL::OMNIBOX_API_EXTENSION);
 244     } else {
 245       pending_extensions_.erase(extension);
 246     }
 247   }
 248 }
 249
 250 gfx::Image OmniboxAPI::GetOmniboxIcon(const std::string& extension_id) {
 251   return gfx::Image::CreateFrom1xBitmap(
 252       omnibox_icon_manager_.GetIcon(extension_id));
 253 }
 254
 255 gfx::Image OmniboxAPI::GetOmniboxPopupIcon(const std::string& extension_id) {
 256   return gfx::Image::CreateFrom1xBitmap(
 257       omnibox_popup_icon_manager_.GetIcon(extension_id));
 258 }
 259
 260 void OmniboxAPI::OnTemplateURLsLoaded() {
 261   // Register keywords for pending extensions.
 262   template_url_sub_.reset();
 263   for (PendingExtensions::const_iterator i(pending_extensions_.begin());
 264        i != pending_extensions_.end(); ++i) {
 265     url_service_->RegisterOmniboxKeyword(
 266         (*i)->id(), (*i)->name(), OmniboxInfo::GetKeyword(*i),
 267         GetTemplateURLStringForExtension((*i)->id()));
 268   }
 269   pending_extensions_.clear();
 270 }
 271
 272 template <>
 273 void BrowserContextKeyedAPIFactory<OmniboxAPI>::DeclareFactoryDependencies() {
 274   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
 275   DependsOn(ExtensionPrefsFactory::GetInstance());
 276   DependsOn(TemplateURLServiceFactory::GetInstance());
 277 }
 278
 279 bool OmniboxSendSuggestionsFunction::RunSync() {
 280   scoped_ptr<SendSuggestions::Params> params(
 281       SendSuggestions::Params::Create(*args_));
 282   EXTENSION_FUNCTION_VALIDATE(params);
 283
 284   content::NotificationService::current()->Notify(
 285       extensions::NOTIFICATION_EXTENSION_OMNIBOX_SUGGESTIONS_READY,
 286       content::Source<Profile>(GetProfile()->GetOriginalProfile()),
 287       content::Details<SendSuggestions::Params>(params.get()));
 288
 289   return true;
 290 }
 291
 292 bool OmniboxSetDefaultSuggestionFunction::RunSync() {
 293   scoped_ptr<SetDefaultSuggestion::Params> params(
 294       SetDefaultSuggestion::Params::Create(*args_));
 295   EXTENSION_FUNCTION_VALIDATE(params);
 296
 297   if (SetOmniboxDefaultSuggestion(
 298           GetProfile(), extension_id(), params->suggestion)) {
 299     content::NotificationService::current()->Notify(
 300         extensions::NOTIFICATION_EXTENSION_OMNIBOX_DEFAULT_SUGGESTION_CHANGED,
 301         content::Source<Profile>(GetProfile()->GetOriginalProfile()),
 302         content::NotificationService::NoDetails());
 303   }
 304
 305   return true;
 306 }
 307
 308 // This function converts style information populated by the JSON schema
 309 // compiler into an ACMatchClassifications object.
 310 ACMatchClassifications StyleTypesToACMatchClassifications(
 311     const omnibox::SuggestResult &suggestion) {
 312   ACMatchClassifications match_classifications;
 313   if (suggestion.description_styles) {
 314     base::string16 description = base::UTF8ToUTF16(suggestion.description);
 315     std::vector<int> styles(description.length(), 0);
 316
 317     for (std::vector<linked_ptr<omnibox::SuggestResult::DescriptionStylesType> >
 318          ::iterator i = suggestion.description_styles->begin();
 319          i != suggestion.description_styles->end(); ++i) {
 320       omnibox::SuggestResult::DescriptionStylesType* style = i->get();
 321
 322       int length = description.length();
 323       if (style->length)
 324         length = *style->length;
 325
 326       size_t offset = style->offset >= 0 ? style->offset :
 327           std::max(0, static_cast<int>(description.length()) + style->offset);
 328
 329       int type_class;
 330       switch (style->type) {
 331         case omnibox::DESCRIPTION_STYLE_TYPE_URL:
 332           type_class = AutocompleteMatch::ACMatchClassification::URL;
 333           break;
 334         case omnibox::DESCRIPTION_STYLE_TYPE_MATCH:
 335           type_class = AutocompleteMatch::ACMatchClassification::MATCH;
 336           break;
 337         case omnibox::DESCRIPTION_STYLE_TYPE_DIM:
 338           type_class = AutocompleteMatch::ACMatchClassification::DIM;
 339           break;
 340         default:
 341           type_class = AutocompleteMatch::ACMatchClassification::NONE;
 342           return match_classifications;
 343       }
 344
 345       for (size_t j = offset; j < offset + length && j < styles.size(); ++j)
 346         styles[j] |= type_class;
 347     }
 348
 349     for (size_t i = 0; i < styles.size(); ++i) {
 350       if (i == 0 || styles[i] != styles[i-1])
 351         match_classifications.push_back(
 352             ACMatchClassification(i, styles[i]));
 353     }
 354   } else {
 355     match_classifications.push_back(
 356         ACMatchClassification(0, ACMatchClassification::NONE));
 357   }
 358
 359   return match_classifications;
 360 }
 361
 362 void ApplyDefaultSuggestionForExtensionKeyword(
 363     Profile* profile,
 364     const TemplateURL* keyword,
 365     const base::string16& remaining_input,
 366     AutocompleteMatch* match) {
 367   DCHECK(keyword->GetType() == TemplateURL::OMNIBOX_API_EXTENSION);
 368
 369   scoped_ptr<omnibox::SuggestResult> suggestion(
 370       GetOmniboxDefaultSuggestion(profile, keyword->GetExtensionId()));
 371   if (!suggestion || suggestion->description.empty())
 372     return;  // fall back to the universal default
 373
 374   const base::string16 kPlaceholderText(base::ASCIIToUTF16("%s"));
 375   const base::string16 kReplacementText(base::ASCIIToUTF16("<input>"));
 376
 377   base::string16 description = base::UTF8ToUTF16(suggestion->description);
 378   ACMatchClassifications& description_styles = match->contents_class;
 379   description_styles = StyleTypesToACMatchClassifications(*suggestion);
 380
 381   // Replace "%s" with the user's input and adjust the style offsets to the
 382   // new length of the description.
 383   size_t placeholder(description.find(kPlaceholderText, 0));
 384   if (placeholder != base::string16::npos) {
 385     base::string16 replacement =
 386         remaining_input.empty() ? kReplacementText : remaining_input;
 387     description.replace(placeholder, kPlaceholderText.length(), replacement);
 388
 389     for (size_t i = 0; i < description_styles.size(); ++i) {
 390       if (description_styles[i].offset > placeholder)
 391         description_styles[i].offset += replacement.length() - 2;
 392     }
 393   }
 394
 395   match->contents.assign(description);
 396 }
 397
 398 }  // namespace extensions