Add onFontNameChanged event to Font Settings API

chrome/browser/extensions/extension_preference_helpers.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/extension_preference_helpers.h"
 
+#include "base/json/json_writer.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/profiles/profile.h"
+
 namespace {
 
 const char kIncognitoPersistent[] = "incognito_persistent";
 const char kIncognitoSessionOnly[] = "incognito_session_only";
 const char kRegular[] = "regular";
 
+const char kLevelOfControlKey[] = "levelOfControl";
+
+const char kNotControllable[] = "not_controllable";
+const char kControlledByOtherExtensions[] = "controlled_by_other_extensions";
+const char kControllableByThisExtension[] = "controllable_by_this_extension";
+const char kControlledByThisExtension[] = "controlled_by_this_extension";
+
 }  // namespace
 
 namespace extension_preference_helpers {
 
 bool StringToScope(const std::string& s, ExtensionPrefsScope* scope) {
   if (s == kRegular)
     *scope = kExtensionPrefsScopeRegular;
   else if (s == kIncognitoPersistent)
     *scope = kExtensionPrefsScopeIncognitoPersistent;
   else if (s == kIncognitoSessionOnly)
     *scope = kExtensionPrefsScopeIncognitoSessionOnly;
   else
     return false;
   return true;
 }
 
+const char* GetLevelOfControl(
+    Profile* profile,
+    const std::string& extension_id,
+    const std::string& browser_pref,
+    bool incognito) {
+  PrefService* prefs = incognito ? profile->GetOffTheRecordPrefs()
+                                 : profile->GetPrefs();
+  const PrefService::Preference* pref =
+      prefs->FindPreference(browser_pref.c_str());
+  CHECK(pref);
+  ExtensionPrefs* ep = profile->GetExtensionService()->extension_prefs();
+
+  if (!pref->IsExtensionModifiable())
+    return kNotControllable;
+
+  if (ep->DoesExtensionControlPref(extension_id, browser_pref, incognito))
+    return kControlledByThisExtension;
+
+  if (ep->CanExtensionControlPref(extension_id, browser_pref, incognito))
+    return kControllableByThisExtension;
+
+  return kControlledByOtherExtensions;
+}
+
+void DispatchEventToExtensions(
+    Profile* profile,
+    const std::string& event_name,
+    ListValue* args,
+    ExtensionAPIPermission::ID permission,
+    bool incognito,
+    const char* browser_pref) {

[Bernhard Bauer, 2012/04/16 08:00:40]

I think I'd prefer passing around std::string's for as long as possible. 

+  ExtensionEventRouter* router = profile->GetExtensionEventRouter();
+  if (!router || !router->HasEventListener(event_name))
+    return;
+  ExtensionService* extension_service = profile->GetExtensionService();
+  const ExtensionSet* extensions = extension_service->extensions();
+  for (ExtensionSet::const_iterator it = extensions->begin();
+       it != extensions->end(); ++it) {
+    std::string extension_id = (*it)->id();
+    // TODO(bauerb): Only iterate over registered event listeners.
+    if (router->ExtensionHasEventListener(extension_id, event_name) &&
+        (*it)->HasAPIPermission(permission) &&
+        (!incognito || extension_service->CanCrossIncognito(*it))) {
+      std::string json_args;
+
+      // Inject level of control key-value.
+      if (browser_pref) {

[Bernhard Bauer, 2012/04/16 08:00:40]

If we don't have a caller that passes in NULL, I think we can get rid of the
NULL check here (which also allows us to pass in a std::string then).

[falken, 2012/04/16 09:25:31]

Done. My idea was to check in case someone wants to use
DispatchEventToExtensions without the injection behavior, but I see we probably
won't need that.

+        DictionaryValue* dict;
+        bool rv = args->GetDictionary(0, &dict);
+        DCHECK(rv);
+
+        std::string level_of_control =
+            GetLevelOfControl(profile, extension_id, browser_pref, incognito);
+        dict->SetString(kLevelOfControlKey, level_of_control);
+      }
+
+      base::JSONWriter::Write(args, &json_args);
+      router->DispatchEventToExtension(
+          extension_id, event_name, json_args, NULL, GURL());
+    }
+  }
+}
+
 }  // namespace extension_preference_helpers