Add more management policy checking after extension installed

extensions/browser/extension_prefs.cc

 // Copyright 2014 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 "extensions/browser/extension_prefs.h"
 
 #include <iterator>
 
 #include "base/command_line.h"
 #include "base/prefs/pref_notifier.h"
@@ skipping 1147 matching lines @@
   return id_list_out;
 }
 
 void ExtensionPrefs::SetToolbarOrder(const ExtensionIdList& extension_ids) {
   SetExtensionPrefFromContainer(pref_names::kToolbar, extension_ids);
 }
 
 void ExtensionPrefs::OnExtensionInstalled(
     const Extension* extension,
     Extension::State initial_state,
+    Extension::DisableReason initial_disable_reason,
     const syncer::StringOrdinal& page_ordinal,
     int install_flags,
     const std::string& install_parameter) {
   ScopedExtensionPrefUpdate update(prefs_, extension->id());
   base::DictionaryValue* extension_dict = update.Get();
   const base::Time install_time = time_provider_->GetCurrentTime();
   PopulateExtensionInfoPrefs(extension,
                              install_time,
                              initial_state,
+                             initial_disable_reason,
                              install_flags,
                              install_parameter,
                              extension_dict);
 
   bool requires_sort_ordinal = extension->RequiresSortOrdinal() &&
                                (install_flags & kInstallFlagIsEphemeral) == 0;
   FinishExtensionInfoPrefs(extension->id(),
                            install_time,
                            requires_sort_ordinal,
                            page_ordinal,
@@ skipping 182 matching lines @@
     if (info)
       extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release()));
   }
 
   return extensions_info.Pass();
 }
 
 void ExtensionPrefs::SetDelayedInstallInfo(
     const Extension* extension,
     Extension::State initial_state,
+    Extension::DisableReason initial_disable_reason,
     int install_flags,
     DelayReason delay_reason,
     const syncer::StringOrdinal& page_ordinal,
     const std::string& install_parameter) {
   base::DictionaryValue* extension_dict = new base::DictionaryValue();
   PopulateExtensionInfoPrefs(extension,
                              time_provider_->GetCurrentTime(),
                              initial_state,
+                             initial_disable_reason,
                              install_flags,
                              install_parameter,
                              extension_dict);
 
   // Add transient data that is needed by FinishDelayedInstallInfo(), but
   // should not be in the final extension prefs. All entries here should have
   // a corresponding Remove() call in FinishDelayedInstallInfo().
   if (extension->RequiresSortOrdinal() &&
       (install_flags & kInstallFlagIsEphemeral) == 0) {
     extension_dict->SetString(
@@ skipping 556 matching lines @@
   for (typename ExtensionIdContainer::const_iterator iter = strings.begin();
        iter != strings.end(); ++iter) {
     list_of_values->Append(new base::StringValue(*iter));
   }
 }
 
 void ExtensionPrefs::PopulateExtensionInfoPrefs(
     const Extension* extension,
     const base::Time install_time,
     Extension::State initial_state,
+    Extension::DisableReason initial_disable_reason,
     int install_flags,
     const std::string& install_parameter,
     base::DictionaryValue* extension_dict) {
   extension_dict->Set(kPrefState, new base::FundamentalValue(initial_state));
+  // Update kPrefDisableReasons to add new disable reason if the extension is
+  // initially set to be disabled.
+  if (initial_state == Extension::DISABLED)
+    AddDisableReason(extension->id(), initial_disable_reason);
   extension_dict->Set(kPrefLocation,
                       new base::FundamentalValue(extension->location()));
   extension_dict->Set(kPrefCreationFlags,
                       new base::FundamentalValue(extension->creation_flags()));
   extension_dict->Set(kPrefFromWebStore,
                       new base::FundamentalValue(extension->from_webstore()));
   extension_dict->Set(kPrefFromBookmark,
                       new base::FundamentalValue(extension->from_bookmark()));
   extension_dict->Set(
       kPrefWasInstalledByDefault,
@@ skipping 124 matching lines @@
   extension_pref_value_map_->RegisterExtension(
       extension_id, install_time, is_enabled, is_incognito_enabled);
 
   FOR_EACH_OBSERVER(
       ExtensionPrefsObserver,
       observer_list_,
       OnExtensionRegistered(extension_id, install_time, is_enabled));
 }
 
 }  // namespace extensions