Fixes and improvements to cloud policy for extensions.

chrome/browser/extensions/api/storage/managed_value_store_cache.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/storage/managed_value_store_cache.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/file_util.h"
@@ skipping 20 matching lines @@
 #include "components/policy/core/common/schema_registry.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
+#include "extensions/common/one_shot_event.h"
 #include "extensions/common/permissions/api_permission.h"
 
 using content::BrowserThread;
 
 namespace extensions {
 
 namespace storage = api::storage;
 
 namespace {
 
@@ skipping 48 matching lines @@
                  content::Source<Profile>(profile_));
   registrar_.Add(this,
                  chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
                  content::Source<Profile>(profile_));
 }
 
 void ManagedValueStoreCache::ExtensionTracker::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
+  // Some extensions are installed on the first run before the ExtensionService
+  // becomes ready. Wait until all of them are ready before registering the
+  // schemas of managed extensions, so that the policy loaders are reloaded at
+  // most once.
+  if (!ExtensionSystem::Get(profile_)->ready().is_signaled())
+    return;
+
   scoped_ptr<ExtensionSet> added;
   const Extension* removed = NULL;
 
   switch (type) {
     case chrome::NOTIFICATION_EXTENSIONS_READY: {
       ExtensionService* service =
           ExtensionSystem::Get(profile_)->extension_service();
       added = service->GenerateInstalledExtensionsSet();
       break;
     }
@@ skipping 143 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   callback.Run(GetStoreFor(extension->id()));
 }
 
 void ManagedValueStoreCache::DeleteStorageSoon(
     const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   // It's possible that the store exists, but hasn't been loaded yet
   // (because the extension is unloaded, for example). Open the database to
   // clear it if it exists.
-  // TODO(joaodasilva): move this check to a ValueStore method.
-  if (!base::DirectoryExists(base_path_.AppendASCII(extension_id)))
+  if (!HasStore(extension_id))
     return;
   GetStoreFor(extension_id)->DeleteStorage();
   store_map_.erase(extension_id);
 }
 
 void ManagedValueStoreCache::OnPolicyServiceInitialized(
     policy::PolicyDomain domain) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (domain != policy::POLICY_DOMAIN_EXTENSIONS)
@@ skipping 37 matching lines @@
       base::Bind(&ManagedValueStoreCache::UpdatePolicyOnFILE,
                  base::Unretained(this),
                  ns.component_id,
                  base::Passed(current.DeepCopy())));
 }
 
 void ManagedValueStoreCache::UpdatePolicyOnFILE(
     const std::string& extension_id,
     scoped_ptr<policy::PolicyMap> current_policy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  if (!HasStore(extension_id) && current_policy->empty()) {
+    // Don't create the store now if there are no policies configured for this
+    // extension. If the extension uses the storage.managed API then the store
+    // will be created at RunWithValueStoreForExtension().
+    return;
+  }
+
   GetStoreFor(extension_id)->SetCurrentPolicy(*current_policy);
 }
 
 PolicyValueStore* ManagedValueStoreCache::GetStoreFor(
     const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   PolicyValueStoreMap::iterator it = store_map_.find(extension_id);
   if (it != store_map_.end())
     return it->second.get();
 
   // Create the store now, and serve the cached policy until the PolicyService
   // sends updated values.
   PolicyValueStore* store = new PolicyValueStore(
       extension_id,
       observers_,
       make_scoped_ptr(storage_factory_->Create(base_path_, extension_id)));
   store_map_[extension_id] = make_linked_ptr(store);
 
   return store;
 }
 
+bool ManagedValueStoreCache::HasStore(const std::string& extension_id) const {
+  // TODO(joaodasilva): move this check to a ValueStore method.
+  return base::DirectoryExists(base_path_.AppendASCII(extension_id));
+}
+
 }  // namespace extensions