Supervised User whitelists: update to json format v2

chrome/browser/supervised_user/supervised_user_whitelist_service_unittest.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 <map>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 28 matching lines @@
     : public component_updater::SupervisedUserWhitelistInstaller {
  public:
   MockSupervisedUserWhitelistInstaller() {}
   ~MockSupervisedUserWhitelistInstaller() override {}
 
   const std::set<std::string>& registered_whitelists() {
     return registered_whitelists_;
   }
 
   void NotifyWhitelistReady(const std::string& crx_id,
+                            const base::string16& title,
                             const base::FilePath& path) {
     for (const auto& callback : ready_callbacks_)
-      callback.Run(crx_id, path);
+      callback.Run(crx_id, title, path);
   }
 
   // SupervisedUserWhitelistInstaller implementation:
   void RegisterComponents() override {}
 
   void Subscribe(const WhitelistReadyCallback& callback) override {
     ready_callbacks_.push_back(callback);
   }
 
   void RegisterWhitelist(const std::string& client_id,
@@ skipping 128 matching lines @@
   service_->Init();
   EXPECT_EQ(0u, site_lists_.size());
 
   // Notify that whitelist A is ready.
   base::RunLoop run_loop;
   site_lists_changed_callback_ = run_loop.QuitClosure();
   base::FilePath test_data_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir));
   base::FilePath whitelist_path =
       test_data_dir.AppendASCII("whitelists/content_pack/site_list.json");
-  installer_->NotifyWhitelistReady("aaaa", whitelist_path);
+  installer_->NotifyWhitelistReady("aaaa", base::ASCIIToUTF16("Title"),
+                                   whitelist_path);
   run_loop.Run();
 
   ASSERT_EQ(1u, site_lists_.size());
-  const std::vector<SupervisedUserSiteList::Site>& sites =
-      site_lists_[0]->sites();
-  EXPECT_EQ(3u, sites.size());
-  EXPECT_EQ("YouTube", base::UTF16ToUTF8(sites[0].name));
+  EXPECT_EQ(base::ASCIIToUTF16("Title"), site_lists_[0]->title());
+  EXPECT_EQ(4u, site_lists_[0]->patterns().size());
 
   // Do the initial merge. One item should be added (whitelist C), one should be
   // modified (whitelist B), and one item should be removed (whitelist A).
   syncer::SyncDataList initial_data;
   initial_data.push_back(
       SupervisedUserWhitelistService::CreateWhitelistSyncData(
           "bbbb", "Whitelist B New"));
   initial_data.push_back(
       SupervisedUserWhitelistService::CreateWhitelistSyncData(
           "cccc", "Whitelist C"));
@@ skipping 34 matching lines @@
       FROM_HERE, syncer::SyncChange::ACTION_DELETE,
       SupervisedUserWhitelistService::CreateWhitelistSyncData(
           "aaaa", "Ignored")));
   syncer::SyncError error = service_->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_FALSE(error.IsSet());
 
   EXPECT_EQ(0u, site_lists_.size());
 
   // If whitelist A now becomes ready, it should be ignored.
   installer_->NotifyWhitelistReady(
-      "aaaa", base::FilePath(FILE_PATH_LITERAL("/path/to/aaaa")));
+      "aaaa", base::ASCIIToUTF16("Title"),
+      base::FilePath(FILE_PATH_LITERAL("/path/to/aaaa")));
   EXPECT_EQ(0u, site_lists_.size());
 
   CheckFinalStateAndPreferences();
 }
 
 TEST_F(SupervisedUserWhitelistServiceTest, GetAllSyncData) {
   PrepareInitialStateAndPreferences();
 
   syncer::SyncDataList sync_data =
       service_->GetAllSyncData(syncer::SUPERVISED_USER_WHITELISTS);
   ASSERT_EQ(2u, sync_data.size());
   const sync_pb::ManagedUserWhitelistSpecifics* whitelist =
       FindWhitelist(sync_data, "aaaa");
   ASSERT_TRUE(whitelist);
   EXPECT_EQ("Whitelist A", whitelist->name());
   whitelist = FindWhitelist(sync_data, "bbbb");
   ASSERT_TRUE(whitelist);
   EXPECT_EQ("Whitelist B", whitelist->name());
 }