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

chrome/browser/supervised_user/supervised_user_whitelist_service.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/supervised_user/supervised_user_whitelist_service.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 66 matching lines @@
     std::string id;
     std::string name;
     size_t separator = whitelist.find(':');
     if (separator != base::StringPiece::npos) {
       whitelist.substr(0, separator).CopyToString(&id);
       whitelist.substr(separator + 1).CopyToString(&name);
     } else {
       whitelist.CopyToString(&id);
     }
 
-    // Skip whitelists that were already registered.
-    if (registered_whitelists_.count(id) > 0u)
-      continue;
-
-    bool new_installation = true;
-    RegisterWhitelist(id, name, new_installation);
+    RegisterWhitelist(id, name, FROM_COMMAND_LINE);
   }
 }
 
 void SupervisedUserWhitelistService::AddSiteListsChangedCallback(
     const SiteListsChangedCallback& callback) {
   site_lists_changed_callbacks_.push_back(callback);
 
   std::vector<scoped_refptr<SupervisedUserSiteList>> whitelists;
   GetLoadedWhitelists(&whitelists);
   callback.Run(whitelists);
@@ skipping 159 matching lines @@
     NotifyWhitelistsChanged();
 
   return error;
 }
 
 void SupervisedUserWhitelistService::AddNewWhitelist(
     base::DictionaryValue* pref_dict,
     const sync_pb::ManagedUserWhitelistSpecifics& whitelist) {
   base::RecordAction(base::UserMetricsAction("ManagedUsers_Whitelist_Added"));
 
-  bool new_installation = true;
-  RegisterWhitelist(whitelist.id(), whitelist.name(), new_installation);
+  RegisterWhitelist(whitelist.id(), whitelist.name(), FROM_SYNC);
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
   SetWhitelistProperties(dict.get(), whitelist);
   pref_dict->SetWithoutPathExpansion(whitelist.id(), dict.release());
 }
 
 void SupervisedUserWhitelistService::SetWhitelistProperties(
     base::DictionaryValue* dict,
     const sync_pb::ManagedUserWhitelistSpecifics& whitelist) {
   dict->SetString(kName, whitelist.name());
 }
 
 void SupervisedUserWhitelistService::RemoveWhitelist(
     base::DictionaryValue* pref_dict,
     const std::string& id) {
   base::RecordAction(base::UserMetricsAction("ManagedUsers_Whitelist_Removed"));
 
   pref_dict->RemoveWithoutPathExpansion(id, NULL);
   installer_->UnregisterWhitelist(client_id_, id);
   UnloadWhitelist(id);
 }
 
 void SupervisedUserWhitelistService::RegisterWhitelist(const std::string& id,
                                                        const std::string& name,
-                                                       bool new_installation) {
+                                                       WhitelistSource source) {
   bool result = registered_whitelists_.insert(id).second;
   DCHECK(result);
 
-  installer_->RegisterWhitelist(client_id_, id, name);
+  // Using an empty client ID for whitelists installed from the command line
+  // causes the installer to not persist the installation, so the whitelist will
+  // be removed the next time the browser is started without the command line
+  // flag.
+  std::string client_id;
+  if (source == FROM_SYNC)
+    client_id = client_id_;

[Marc Treib, 2015/10/16 11:03:58]

nit: I'd have put this inline, like
(source == FROM_COMMAND_LINE) ? std::string() : client_id_
(but up to you)

[Bernhard Bauer, 2015/10/16 11:23:13]

Done.

+
+  installer_->RegisterWhitelist(client_id, id, name);
 }
 
 void SupervisedUserWhitelistService::GetLoadedWhitelists(
     std::vector<scoped_refptr<SupervisedUserSiteList>>* whitelists) {
   for (const auto& whitelist : loaded_whitelists_)
     whitelists->push_back(whitelist.second);
 }
 
 void SupervisedUserWhitelistService::NotifyWhitelistsChanged() {
   std::vector<scoped_refptr<SupervisedUserSiteList>> whitelists;
@@ skipping 29 matching lines @@
   UMA_HISTOGRAM_TIMES("ManagedUsers.Whitelist.TotalLoadDuration",
                       base::TimeTicks::Now() - start_time);
 
   // If the whitelist has been unregistered in the mean time, ignore it.
   if (registered_whitelists_.count(id) == 0u)
     return;
 
   loaded_whitelists_[id] = whitelist;
   NotifyWhitelistsChanged();
 }