Don't persist registrations for whitelists installed from the command line.

chrome/browser/component_updater/supervised_user_whitelist_installer.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 "chrome/browser/component_updater/supervised_user_whitelist_installer.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
@@ skipping 368 matching lines @@
 }
 
 void SupervisedUserWhitelistInstallerImpl::RegisterComponents() {
   std::set<std::string> registered_whitelists;
   const base::DictionaryValue* whitelists =
       local_state_->GetDictionary(prefs::kRegisteredSupervisedUserWhitelists);
   for (base::DictionaryValue::Iterator it(*whitelists); !it.IsAtEnd();
        it.Advance()) {
     const base::DictionaryValue* dict = nullptr;
     it.value().GetAsDictionary(&dict);
+
+    // Skip whitelists with no clients. This can happen when a whitelist was
+    // previously registered with an empty client ID.
+    const base::ListValue* clients = nullptr;
+    if (!dict->GetList(kClients, &clients) || clients->empty())
+      continue;
+
     std::string name;
     bool result = dict->GetString(kName, &name);
     DCHECK(result);
     const std::string& id = it.key();
     RegisterComponent(id, name, base::Closure());
 
     registered_whitelists.insert(id);
   }
 
   cus_->GetSequencedTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&RemoveUnregisteredWhitelistsOnTaskRunner,
                             registered_whitelists));
 }
 
 void SupervisedUserWhitelistInstallerImpl::Subscribe(
     const WhitelistReadyCallback& callback) {
   return callbacks_.push_back(callback);
 }
 
 void SupervisedUserWhitelistInstallerImpl::RegisterWhitelist(
     const std::string& client_id,
     const std::string& crx_id,
     const std::string& name) {
   DictionaryPrefUpdate update(local_state_,
                               prefs::kRegisteredSupervisedUserWhitelists);
   base::DictionaryValue* pref_dict = update.Get();
   base::DictionaryValue* whitelist_dict = nullptr;
-  bool newly_added = false;
-  if (!pref_dict->GetDictionaryWithoutPathExpansion(crx_id, &whitelist_dict)) {
+  const bool newly_added =
+      !pref_dict->GetDictionaryWithoutPathExpansion(crx_id, &whitelist_dict);
+  if (newly_added) {
     whitelist_dict = new base::DictionaryValue;
     whitelist_dict->SetString(kName, name);
     pref_dict->SetWithoutPathExpansion(crx_id, whitelist_dict);
-    newly_added = true;
   }
 
-  base::ListValue* clients = nullptr;
-  if (!whitelist_dict->GetList(kClients, &clients)) {
-    DCHECK(newly_added);
-    clients = new base::ListValue;
-    whitelist_dict->Set(kClients, clients);
+  if (!client_id.empty()) {
+    base::ListValue* clients = nullptr;
+    if (!whitelist_dict->GetList(kClients, &clients)) {
+      DCHECK(newly_added);
+      clients = new base::ListValue;
+      whitelist_dict->Set(kClients, clients);
+    }
+    bool success =
+        clients->AppendIfNotPresent(new base::StringValue(client_id));
+    DCHECK(success);
   }
-  bool success = clients->AppendIfNotPresent(new base::StringValue(client_id));
-  DCHECK(success);
 
   if (!newly_added) {
     // Sanity-check that the stored name is equal to the name passed in.
     // In release builds this is a no-op.
     std::string stored_name;
     DCHECK(whitelist_dict->GetString(kName, &stored_name));
     DCHECK_EQ(stored_name, name);
     return;
   }
 
@@ skipping 72 matching lines @@
 
 // static
 void SupervisedUserWhitelistInstaller::TriggerComponentUpdate(
     OnDemandUpdater* updater,
     const std::string& crx_id) {
   const bool result = updater->OnDemandUpdate(crx_id);
   DCHECK(result);
 }
 
 }  // namespace component_updater