Persist the extension omnibox default suggestion to Prefs.

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

 // Copyright (c) 2012 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.
 
 #include "chrome/browser/extensions/api/omnibox/omnibox_api.h"
 
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_event_router.h"
+#include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/webui/ntp/app_launcher_handler.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "content/public/browser/notification_service.h"
 
 namespace events {
 const char kOnInputStarted[] = "omnibox.onInputStarted";
 const char kOnInputChanged[] = "omnibox.onInputChanged";
 const char kOnInputEntered[] = "omnibox.onInputEntered";
 const char kOnInputCancelled[] = "omnibox.onInputCancelled";
 }  // namespace events
 
 namespace extensions {
 
 namespace {
 const char kDescriptionStylesOrderError[] =
     "Suggestion descriptionStyles must be in increasing non-overlapping order.";
 const char kDescriptionStylesLengthError[] =
     "Suggestion descriptionStyles contains an offset longer than the"
     " description text";
 
 const char kSuggestionContent[] = "content";
 const char kSuggestionDescription[] = "description";
 const char kSuggestionDescriptionStyles[] = "descriptionStyles";
+const char kSuggestionDescriptionStylesRaw[] = "descriptionStylesRaw";
 const char kDescriptionStylesType[] = "type";
 const char kDescriptionStylesOffset[] = "offset";
 const char kDescriptionStylesLength[] = "length";
 
-static base::LazyInstance<base::PropertyAccessor<ExtensionOmniboxSuggestion> >
-    g_extension_omnibox_suggestion_property_accessor =
-        LAZY_INSTANCE_INITIALIZER;
-
-base::PropertyAccessor<ExtensionOmniboxSuggestion>& GetPropertyAccessor() {
-  return g_extension_omnibox_suggestion_property_accessor.Get();
-}
-
-// Returns the suggestion object set by the extension via the
-// omnibox.setDefaultSuggestion call, or NULL if it was never set.
-const ExtensionOmniboxSuggestion* GetDefaultSuggestionForExtension(
-    Profile* profile, const std::string& extension_id) {
-  const Extension* extension =
-      profile->GetExtensionService()->GetExtensionById(extension_id, false);
-  if (!extension)
-    return NULL;
-  return GetPropertyAccessor().GetProperty(
-      profile->GetExtensionService()->GetPropertyBag(extension));
-}
-
 }  // namespace
 
 // static
 void ExtensionOmniboxEventRouter::OnInputStarted(
     Profile* profile, const std::string& extension_id) {
   profile->GetExtensionEventRouter()->DispatchEventToExtension(
       extension_id, events::kOnInputStarted, "[]", profile, GURL());
 }
 
 // static
@@ skipping 45 matching lines @@
   ListValue* suggestions_value;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &suggestions.request_id));
   EXTENSION_FUNCTION_VALIDATE(args_->GetList(1, &suggestions_value));
 
   suggestions.suggestions.resize(suggestions_value->GetSize());
   for (size_t i = 0; i < suggestions_value->GetSize(); ++i) {
     ExtensionOmniboxSuggestion& suggestion = suggestions.suggestions[i];
     DictionaryValue* suggestion_value;
     EXTENSION_FUNCTION_VALIDATE(suggestions_value->GetDictionary(
         i, &suggestion_value));
-    EXTENSION_FUNCTION_VALIDATE(suggestion_value->GetString(
-        kSuggestionContent, &suggestion.content));
-    EXTENSION_FUNCTION_VALIDATE(suggestion_value->GetString(
-        kSuggestionDescription, &suggestion.description));
-
-    if (suggestion_value->HasKey(kSuggestionDescriptionStyles)) {
-      ListValue* styles;
-      EXTENSION_FUNCTION_VALIDATE(
-          suggestion_value->GetList(kSuggestionDescriptionStyles, &styles));
-      EXTENSION_FUNCTION_VALIDATE(suggestion.ReadStylesFromValue(*styles));
-    } else {
-      suggestion.description_styles.clear();
-      suggestion.description_styles.push_back(
-          ACMatchClassification(0, ACMatchClassification::NONE));
-    }
+    EXTENSION_FUNCTION_VALIDATE(suggestion.Populate(*suggestion_value, true));
   }
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_OMNIBOX_SUGGESTIONS_READY,
       content::Source<Profile>(profile_->GetOriginalProfile()),
       content::Details<ExtensionOmniboxSuggestions>(&suggestions));
 
   return true;
 }
 
 bool OmniboxSetDefaultSuggestionFunction::RunImpl() {
   ExtensionOmniboxSuggestion suggestion;
   DictionaryValue* suggestion_value;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &suggestion_value));
-  EXTENSION_FUNCTION_VALIDATE(suggestion_value->GetString(
-      kSuggestionDescription, &suggestion.description));
+  EXTENSION_FUNCTION_VALIDATE(suggestion.Populate(*suggestion_value, false));
 
-  if (suggestion_value->HasKey(kSuggestionDescriptionStyles)) {
-    ListValue* styles;
-    EXTENSION_FUNCTION_VALIDATE(
-        suggestion_value->GetList(kSuggestionDescriptionStyles, &styles));
-    EXTENSION_FUNCTION_VALIDATE(suggestion.ReadStylesFromValue(*styles));
-  } else {
-    suggestion.description_styles.clear();
-    suggestion.description_styles.push_back(
-        ACMatchClassification(0, ACMatchClassification::NONE));
-  }
-
-  // Store the suggestion in the extension's runtime data.
-  GetPropertyAccessor().SetProperty(
-      profile_->GetExtensionService()->GetPropertyBag(GetExtension()),
-      suggestion);
+  ExtensionPrefs* prefs =
+      ExtensionSystem::Get(profile())->extension_service()->extension_prefs();
+  if (prefs)
+    prefs->SetOmniboxDefaultSuggestion(extension_id(), suggestion);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_OMNIBOX_DEFAULT_SUGGESTION_CHANGED,
       content::Source<Profile>(profile_->GetOriginalProfile()),
       content::NotificationService::NoDetails());
 
   return true;
 }
 
 ExtensionOmniboxSuggestion::ExtensionOmniboxSuggestion() {}
 
 ExtensionOmniboxSuggestion::~ExtensionOmniboxSuggestion() {}
 
+bool ExtensionOmniboxSuggestion::Populate(const base::DictionaryValue& value,
+                                          bool require_content) {
+  if (!value.GetString(kSuggestionContent, &content) && require_content)
+    return false;
+
+  if (!value.GetString(kSuggestionDescription, &description))
+    return false;
+
+  description_styles.clear();
+  if (value.HasKey(kSuggestionDescriptionStyles)) {
+    // This version comes from the extension.
+    ListValue* styles = NULL;
+    if (!value.GetList(kSuggestionDescriptionStyles, &styles) ||
+        !ReadStylesFromValue(*styles)) {
+      return false;
+    }
+  } else if (value.HasKey(kSuggestionDescriptionStylesRaw)) {
+    // This version comes from ToValue(), which we use to persist to disk.
+    ListValue* styles = NULL;
+    if (!value.GetList(kSuggestionDescriptionStylesRaw, &styles) ||
+        styles->empty()) {
+      return false;
+    }
+    for (size_t i = 0; i < styles->GetSize(); ++i) {
+      base::DictionaryValue* style = NULL;
+      int offset, type;
+      if (!styles->GetDictionary(i, &style))
+        return false;
+      if (!style->GetInteger(kDescriptionStylesType, &type))
+        return false;
+      if (!style->GetInteger(kDescriptionStylesOffset, &offset))
+        return false;
+      description_styles.push_back(ACMatchClassification(offset, type));
+    }
+  } else {
+    description_styles.push_back(
+        ACMatchClassification(0, ACMatchClassification::NONE));
+  }
+
+  return true;
+}
+
 bool ExtensionOmniboxSuggestion::ReadStylesFromValue(
     const ListValue& styles_value) {
   description_styles.clear();
 
   // Step 1: Build a vector of styles, 1 per character of description text.
   std::vector<int> styles;
   styles.resize(description.length());  // sets all styles to 0
 
   for (size_t i = 0; i < styles_value.GetSize(); ++i) {
     DictionaryValue* style;
@@ skipping 26 matching lines @@
 
   // Step 2: Convert the vector into continuous runs of common styles.
   for (size_t i = 0; i < styles.size(); ++i) {
     if (i == 0 || styles[i] != styles[i-1])
       description_styles.push_back(ACMatchClassification(i, styles[i]));
   }
 
   return true;
 }
 
+scoped_ptr<base::DictionaryValue> ExtensionOmniboxSuggestion::ToValue() const {
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+
+  value->SetString(kSuggestionContent, content);
+  value->SetString(kSuggestionDescription, description);
+
+  if (description_styles.size() > 0) {
+    base::ListValue* styles_value = new base::ListValue();
+    for (size_t i = 0; i < description_styles.size(); ++i) {
+      base::DictionaryValue* style = new base::DictionaryValue();
+      style->SetInteger(kDescriptionStylesOffset, description_styles[i].offset);
+      style->SetInteger(kDescriptionStylesType, description_styles[i].style);
+      styles_value->Append(style);
+    }
+
+    value->Set(kSuggestionDescriptionStylesRaw, styles_value);
+  }
+
+  return value.Pass();
+}
+
 ExtensionOmniboxSuggestions::ExtensionOmniboxSuggestions() : request_id(0) {}
 
 ExtensionOmniboxSuggestions::~ExtensionOmniboxSuggestions() {}
 
 void ApplyDefaultSuggestionForExtensionKeyword(
     Profile* profile,
     const TemplateURL* keyword,
     const string16& remaining_input,
     AutocompleteMatch* match) {
   DCHECK(keyword->IsExtensionKeyword());
-  const ExtensionOmniboxSuggestion* suggestion =
-      GetDefaultSuggestionForExtension(profile, keyword->GetExtensionId());
-  if (!suggestion)
+
+  ExtensionPrefs* prefs =
+      ExtensionSystem::Get(profile)->extension_service()->extension_prefs();
+  if (!prefs)
+    return;
+
+  ExtensionOmniboxSuggestion suggestion =
+      prefs->GetOmniboxDefaultSuggestion(keyword->GetExtensionId());
+  if (suggestion.description.empty())
     return;  // fall back to the universal default
 
   const string16 kPlaceholderText(ASCIIToUTF16("%s"));
   const string16 kReplacementText(ASCIIToUTF16("<input>"));
 
-  string16 description = suggestion->description;
+  string16 description = suggestion.description;
   ACMatchClassifications& description_styles = match->contents_class;
-  description_styles = suggestion->description_styles;
+  description_styles = suggestion.description_styles;
 
   // Replace "%s" with the user's input and adjust the style offsets to the
   // new length of the description.
-  size_t placeholder(suggestion->description.find(kPlaceholderText, 0));
+  size_t placeholder(suggestion.description.find(kPlaceholderText, 0));
   if (placeholder != string16::npos) {
     string16 replacement =
         remaining_input.empty() ? kReplacementText : remaining_input;
     description.replace(placeholder, kPlaceholderText.length(), replacement);
 
     for (size_t i = 0; i < description_styles.size(); ++i) {
       if (description_styles[i].offset > placeholder)
         description_styles[i].offset += replacement.length() - 2;
     }
   }
@@ skipping 20 matching lines @@
   // preference is set, launch as a regular tab.
   extension_misc::LaunchContainer launch_container =
       service->extension_prefs()->GetLaunchContainer(
           extension, ExtensionPrefs::LAUNCH_REGULAR);
 
   Browser::OpenApplication(profile, extension, launch_container, GURL(),
                            disposition);
 }
 
 }  // namespace extensions