Add user customizable launch type for apps.

chrome/browser/extensions/extension_prefs.cc

 // Copyright (c) 2010 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_prefs.h"
 
 #include "base/string_util.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/pref_names.h"
 
 using base::Time;
 
 namespace {
 
-// Preferences keys
-
-// A preference that keeps track of per-extension settings. This is a dictionary
-// object read from the Preferences file, keyed off of extension id's.
-const char kExtensionsPref[] = "extensions.settings";
+// Additional preferences keys
 
 // Where an extension was installed from. (see Extension::Location)
 const char kPrefLocation[] = "location";
 
 // Enabled, disabled, killed, etc. (see Extension::State)
 const char kPrefState[] = "state";
 
 // The path to the current version's manifest file.
 const char kPrefPath[] = "path";
 
@@ skipping 40 matching lines @@
 const char kPrefIncognitoEnabled[] = "incognito";
 
 // A preference to control whether an extension is allowed to inject script in
 // pages with file URLs.
 const char kPrefAllowFileAccess[] = "allowFileAccess";
 
 // A preference set by the web store to indicate login information for
 // purchased apps.
 const char kWebStoreLogin[] = "extensions.webstore_login";
 
+// A preference set by the the NTP to persist the desired launch container type
+// used for apps.
+const char kPrefLaunchType[] = "launchType";
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace {
 
 // TODO(asargent) - This is cleanup code for a key that was introduced into
 // the extensions.settings sub-dictionary which wasn't a valid extension
 // id. We can remove this in a couple of months. (See http://crbug.com/40017
 // and http://crbug.com/39745 for more details).
 static void CleanupBadExtensionKeys(PrefService* prefs) {
-  DictionaryValue* dictionary = prefs->GetMutableDictionary(kExtensionsPref);
+  DictionaryValue* dictionary =
+      prefs->GetMutableDictionary(ExtensionPrefs::kExtensionsPref);
   std::set<std::string> bad_keys;
   for (DictionaryValue::key_iterator i = dictionary->begin_keys();
        i != dictionary->end_keys(); ++i) {
     const std::string& key_name(*i);
     if (!Extension::IdIsValid(key_name)) {
       bad_keys.insert(key_name);
     }
   }
   bool dirty = false;
   for (std::set<std::string>::iterator i = bad_keys.begin();
@@ skipping 10 matching lines @@
 ExtensionPrefs::ExtensionPrefs(PrefService* prefs, const FilePath& root_dir)
     : prefs_(prefs),
       install_directory_(root_dir) {
   // TODO(asargent) - Remove this in a couple of months. (See comment above
   // CleanupBadExtensionKeys).
   CleanupBadExtensionKeys(prefs);
 
   MakePathsRelative();
 }
 
+// static
+const char ExtensionPrefs::kExtensionsPref[] = "extensions.settings";
+
 static FilePath::StringType MakePathRelative(const FilePath& parent,
                                              const FilePath& child,
                                              bool *dirty) {
   if (!parent.IsParent(child))
     return child.value();
 
   if (dirty)
     *dirty = true;
   FilePath::StringType retval = child.value().substr(
       parent.value().length());
@@ skipping 23 matching lines @@
     FilePath::StringType path_string;
     if (!extension_dict->GetString(kPrefPath, &path_string))
       continue;
     FilePath path(path_string);
     if (path.IsAbsolute()) {
       extension_dict->SetString(kPrefPath,
           MakePathRelative(install_directory_, path, &dirty));
     }
   }
   if (dirty)
-    prefs_->ScheduleSavePersistentPrefs();
+    SavePrefsAndNotify();
 }
 
 void ExtensionPrefs::MakePathsAbsolute(DictionaryValue* dict) {
   if (!dict || dict->empty())
     return;
 
   for (DictionaryValue::key_iterator i = dict->begin_keys();
        i != dict->end_keys(); ++i) {
     DictionaryValue* extension_dict;
     if (!dict->GetDictionaryWithoutPathExpansion(*i, &extension_dict)) {
@@ skipping 48 matching lines @@
     return false;
 
   DictionaryValue* ext = NULL;
   if (!extensions->GetDictionary(extension_id, &ext)) {
     // No such extension yet.
     return false;
   }
   return ReadBooleanFromPref(ext, pref_key);
 }
 
+bool ExtensionPrefs::ReadIntegerFromPref(
+    DictionaryValue* ext, const std::string& pref_key, int* out_value) {
+  if (!ext->HasKey(pref_key)) return false;
+  if (!ext->GetInteger(pref_key, out_value)) {
+    NOTREACHED() << "Failed to fetch " << pref_key << " flag.";
+    // In case we could not fetch the flag, we treat it as false.
+    return false;
+  }
+  return out_value != NULL;
+}
+
+bool ExtensionPrefs::ReadExtensionPrefInteger(
+    const std::string& extension_id, const std::string& pref_key,
+    int* out_value) {
+  const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
+  if (!extensions)
+    return false;
+  DictionaryValue* ext = NULL;
+  if (!extensions->GetDictionary(extension_id, &ext)) {
+    // No such extension yet.
+    return false;
+  }
+  return ReadIntegerFromPref(ext, pref_key, out_value);
+}
+
+void ExtensionPrefs::SavePrefsAndNotify() {
+  prefs_->ScheduleSavePersistentPrefs();
+  prefs_->pref_notifier()->OnUserPreferenceSet(kExtensionsPref);
+}
+
 bool ExtensionPrefs::IsBlacklistBitSet(DictionaryValue* ext) {
   return ReadBooleanFromPref(ext, kPrefBlacklist);
 }
 
 bool ExtensionPrefs::IsExtensionBlacklisted(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefBlacklist);
 }
 
 bool ExtensionPrefs::IsExtensionAllowedByPolicy(
     const std::string& extension_id) {
@@ skipping 36 matching lines @@
 bool ExtensionPrefs::DidExtensionEscalatePermissions(
     const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id,
                                   kExtensionDidEscalatePermissions);
 }
 
 void ExtensionPrefs::SetDidExtensionEscalatePermissions(
     Extension* extension, bool did_escalate) {
   UpdateExtensionPref(extension->id(), kExtensionDidEscalatePermissions,
                       Value::CreateBooleanValue(did_escalate));
-  prefs_->SavePersistentPrefs();
+  prefs_->ScheduleSavePersistentPrefs();
 }
 
 void ExtensionPrefs::UpdateBlacklist(
     const std::set<std::string>& blacklist_set) {
   std::vector<std::string> remove_pref_ids;
   std::set<std::string> used_id_set;
   const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
 
   if (extensions) {
     for (DictionaryValue::key_iterator extension_id = extensions->begin_keys();
@@ skipping 33 matching lines @@
   std::set<std::string>::const_iterator set_itr = blacklist_set.begin();
   for (; set_itr != blacklist_set.end(); ++set_itr) {
     if (used_id_set.find(*set_itr) == used_id_set.end()) {
       UpdateExtensionPref(*set_itr, kPrefBlacklist,
         Value::CreateBooleanValue(true));
     }
   }
   for (unsigned int i = 0; i < remove_pref_ids.size(); ++i) {
     DeleteExtensionPrefs(remove_pref_ids[i]);
   }
-  // Update persistent registry
-  prefs_->ScheduleSavePersistentPrefs();
+  SavePrefsAndNotify();
   return;
 }
 
 Time ExtensionPrefs::LastPingDayImpl(const DictionaryValue* dictionary) const {
   if (dictionary && dictionary->HasKey(kLastPingDay)) {
     std::string string_value;
     int64 value;
     dictionary->GetString(kLastPingDay, &string_value);
     if (base::StringToInt64(string_value, &value)) {
       return Time::FromInternalValue(value);
     }
   }
   return Time();
 }
 
 void ExtensionPrefs::SetLastPingDayImpl(const Time& time,
                                         DictionaryValue* dictionary) {
   if (!dictionary) {
     NOTREACHED();
     return;
   }
   std::string value = base::Int64ToString(time.ToInternalValue());
   dictionary->SetString(kLastPingDay, value);
-  prefs_->ScheduleSavePersistentPrefs();
+  SavePrefsAndNotify();
 }
 
 Time ExtensionPrefs::LastPingDay(const std::string& extension_id) const {
   DCHECK(Extension::IdIsValid(extension_id));
   return LastPingDayImpl(GetExtensionPref(extension_id));
 }
 
 Time ExtensionPrefs::BlacklistLastPingDay() const {
   return LastPingDayImpl(prefs_->GetDictionary(kExtensionsBlacklistUpdate));
 }
@@ skipping 10 matching lines @@
 }
 
 bool ExtensionPrefs::IsIncognitoEnabled(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefIncognitoEnabled);
 }
 
 void ExtensionPrefs::SetIsIncognitoEnabled(const std::string& extension_id,
                                            bool enabled) {
   UpdateExtensionPref(extension_id, kPrefIncognitoEnabled,
                       Value::CreateBooleanValue(enabled));
-  prefs_->SavePersistentPrefs();
+  SavePrefsAndNotify();
 }
 
 bool ExtensionPrefs::AllowFileAccess(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefAllowFileAccess);
 }
 
 void ExtensionPrefs::SetAllowFileAccess(const std::string& extension_id,
                                         bool allow) {
   UpdateExtensionPref(extension_id, kPrefAllowFileAccess,
                       Value::CreateBooleanValue(allow));
-  prefs_->SavePersistentPrefs();
+  SavePrefsAndNotify();
+}
+
+ExtensionPrefs::LaunchType ExtensionPrefs::GetLaunchType(
+    const std::string& extension_id) {
+  int value;
+  if (ReadExtensionPrefInteger(extension_id, kPrefLaunchType, &value) && (
+      value == LAUNCH_PINNED ||
+      value == LAUNCH_REGULAR ||
+      value == LAUNCH_FULLSCREEN)) {
+    return static_cast<LaunchType>(value);
+  }
+  return LAUNCH_PINNED;
+}
+
+void ExtensionPrefs::SetLaunchType(const std::string& extension_id,
+                                   LaunchType launch_type) {
+  UpdateExtensionPref(extension_id, kPrefLaunchType,
+      Value::CreateIntegerValue(static_cast<int>(launch_type)));
+  SavePrefsAndNotify();
 }
 
 void ExtensionPrefs::GetKilledExtensionIds(std::set<std::string>* killed_ids) {
   const DictionaryValue* dict = prefs_->GetDictionary(kExtensionsPref);
   if (!dict || dict->empty())
     return;
 
   for (DictionaryValue::key_iterator i = dict->begin_keys();
        i != dict->end_keys(); ++i) {
     const std::string& key_name(*i);
@@ skipping 31 matching lines @@
 }
 
 void ExtensionPrefs::SetToolbarOrder(
     const std::vector<std::string>& extension_ids) {
   ListValue* toolbar_order = prefs_->GetMutableList(kExtensionToolbar);
   toolbar_order->Clear();
   for (std::vector<std::string>::const_iterator iter = extension_ids.begin();
        iter != extension_ids.end(); ++iter) {
     toolbar_order->Append(new StringValue(*iter));
   }
-  prefs_->ScheduleSavePersistentPrefs();
+  SavePrefsAndNotify();
 }
 
 void ExtensionPrefs::OnExtensionInstalled(
     Extension* extension, Extension::State initial_state,
     bool initial_incognito_enabled) {
   const std::string& id = extension->id();
   UpdateExtensionPref(id, kPrefState,
                       Value::CreateIntegerValue(initial_state));
   UpdateExtensionPref(id, kPrefIncognitoEnabled,
                       Value::CreateBooleanValue(initial_incognito_enabled));
   UpdateExtensionPref(id, kPrefLocation,
                       Value::CreateIntegerValue(extension->location()));
   FilePath::StringType path = MakePathRelative(install_directory_,
       extension->path(), NULL);
   UpdateExtensionPref(id, kPrefPath, Value::CreateStringValue(path));
   // We store prefs about LOAD extensions, but don't cache their manifest
   // since it may change on disk.
   if (extension->location() != Extension::LOAD) {
     UpdateExtensionPref(id, kPrefManifest,
                         extension->manifest_value()->DeepCopy());
   }
-  prefs_->SavePersistentPrefs();
+  SavePrefsAndNotify();
 }
 
 void ExtensionPrefs::OnExtensionUninstalled(const std::string& extension_id,
                                             const Extension::Location& location,
                                             bool external_uninstall) {
   // For external extensions, we save a preference reminding ourself not to try
   // and install the extension anymore (except when |external_uninstall| is
   // true, which signifies that the registry key was deleted or the pref file
   // no longer lists the extension).
   if (!external_uninstall && Extension::IsExternalLocation(location)) {
     UpdateExtensionPref(extension_id, kPrefState,
                         Value::CreateIntegerValue(Extension::KILLBIT));
-    prefs_->ScheduleSavePersistentPrefs();
+    SavePrefsAndNotify();
   } else {
     DeleteExtensionPrefs(extension_id);
   }
 }
 
 Extension::State ExtensionPrefs::GetExtensionState(
     const std::string& extension_id) {
   DictionaryValue* extension = GetExtensionPref(extension_id);
 
   // If the extension doesn't have a pref, it's a --load-extension.
   if (!extension)
     return Extension::ENABLED;
 
   int state = -1;
   if (!extension->GetInteger(kPrefState, &state) ||
       state < 0 || state >= Extension::NUM_STATES) {
     LOG(ERROR) << "Bad or missing pref 'state' for extension '"
                << extension_id << "'";
     return Extension::ENABLED;
   }
   return static_cast<Extension::State>(state);
 }
 
 void ExtensionPrefs::SetExtensionState(Extension* extension,
                                        Extension::State state) {
   UpdateExtensionPref(extension->id(), kPrefState,
                       Value::CreateIntegerValue(state));
-  prefs_->SavePersistentPrefs();
+  SavePrefsAndNotify();
 }
 
 std::string ExtensionPrefs::GetVersionString(const std::string& extension_id) {
   DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return std::string();
 
   std::string version;
   if (!extension->GetString(kPrefVersion, &version)) {
     LOG(ERROR) << "Bad or missing pref 'version' for extension '"
                << extension_id << "'";
   }
 
   return version;
 }
 
 void ExtensionPrefs::UpdateManifest(Extension* extension) {
   if (extension->location() != Extension::LOAD) {
     UpdateExtensionPref(extension->id(), kPrefManifest,
                         extension->manifest_value()->DeepCopy());
-    prefs_->ScheduleSavePersistentPrefs();
+    SavePrefsAndNotify();
   }
 }
 
 FilePath ExtensionPrefs::GetExtensionPath(const std::string& extension_id) {
   const DictionaryValue* dict = prefs_->GetDictionary(kExtensionsPref);
   if (!dict || dict->empty())
     return FilePath();
 
   std::string path;
   if (!dict->GetString(extension_id + "." + kPrefPath, &path))
@@ skipping 10 matching lines @@
     return;
   }
   DictionaryValue* extension = GetOrCreateExtensionPref(extension_id);
   extension->Set(key, data_value);
 }
 
 void ExtensionPrefs::DeleteExtensionPrefs(const std::string& extension_id) {
   DictionaryValue* dict = prefs_->GetMutableDictionary(kExtensionsPref);
   if (dict->HasKey(extension_id)) {
     dict->Remove(extension_id, NULL);
-    prefs_->ScheduleSavePersistentPrefs();
+    SavePrefsAndNotify();
   }
 }
 
 DictionaryValue* ExtensionPrefs::GetOrCreateExtensionPref(
     const std::string& extension_id) {
   DCHECK(Extension::IdIsValid(extension_id));
   DictionaryValue* dict = prefs_->GetMutableDictionary(kExtensionsPref);
   DictionaryValue* extension = NULL;
   if (!dict->GetDictionary(extension_id, &extension)) {
     // Extension pref does not exist, create it.
@@ skipping 119 matching lines @@
     NOTREACHED();
     return;
   }
   extension_prefs->Remove(kIdleInstallInfo, NULL);
   DictionaryValue* info = new DictionaryValue();
   info->SetString(kIdleInstallInfoCrxPath, crx_path.value());
   info->SetString(kIdleInstallInfoVersion, version);
   info->SetString(kIdleInstallInfoFetchTime,
                   base::Int64ToString(fetch_time.ToInternalValue()));
   extension_prefs->Set(kIdleInstallInfo, info);
-  prefs_->ScheduleSavePersistentPrefs();
+  SavePrefsAndNotify();
 }
 
 bool ExtensionPrefs::RemoveIdleInstallInfo(const std::string& extension_id) {
   DictionaryValue* extension_prefs = GetExtensionPref(extension_id);
   if (!extension_prefs)
     return false;
   bool result = extension_prefs->Remove(kIdleInstallInfo, NULL);
-  prefs_->ScheduleSavePersistentPrefs();
+  SavePrefsAndNotify();
   return result;
 }
 
 bool ExtensionPrefs::GetIdleInstallInfo(const std::string& extension_id,
                                         FilePath* crx_path,
                                         std::string* version,
                                         base::Time* fetch_time) {
   DictionaryValue* extension_prefs = GetExtensionPref(extension_id);
   if (!extension_prefs)
     return false;
@@ skipping 61 matching lines @@
 bool ExtensionPrefs::GetWebStoreLogin(std::string* result) {
   if (prefs_->HasPrefPath(kWebStoreLogin)) {
     *result = prefs_->GetString(kWebStoreLogin);
     return true;
   }
   return false;
 }
 
 void ExtensionPrefs::SetWebStoreLogin(const std::string& login) {
   prefs_->SetString(kWebStoreLogin, login);
-  prefs_->ScheduleSavePersistentPrefs();
+  SavePrefsAndNotify();
 }
 
 // static
 void ExtensionPrefs::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(kExtensionsPref);
   prefs->RegisterListPref(kExtensionToolbar);
   prefs->RegisterIntegerPref(prefs::kExtensionToolbarSize, -1);
   prefs->RegisterDictionaryPref(kExtensionsBlacklistUpdate);
   prefs->RegisterListPref(kExtensionInstallAllowList);
   prefs->RegisterListPref(kExtensionInstallDenyList);
   prefs->RegisterStringPref(kWebStoreLogin, std::string() /* default_value */);
 }