chrome/browser/supervised_user/supervised_user_service_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/scoped_ptr.h"
   6 #include "base/path_service.h"
   7 #include "base/prefs/pref_service.h"
   8 #include "base/prefs/scoped_user_pref_update.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "base/thread_task_runner_handle.h"
  11 #include "chrome/browser/chrome_notification_types.h"
  12 #include "chrome/browser/profiles/profile.h"
  13 #include "chrome/browser/signin/fake_profile_oauth2_token_service.h"
  14 #include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h"
  15 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
  16 #include "chrome/browser/signin/signin_manager_factory.h"
  17 #include "chrome/browser/supervised_user/legacy/custodian_profile_downloader_service.h"
  18 #include "chrome/browser/supervised_user/legacy/custodian_profile_downloader_service_factory.h"
  19 #include "chrome/browser/supervised_user/permission_request_creator.h"
  20 #include "chrome/browser/supervised_user/supervised_user_service.h"
  21 #include "chrome/browser/supervised_user/supervised_user_service_factory.h"
  22 #include "chrome/browser/supervised_user/supervised_user_whitelist_service.h"
  23 #include "chrome/browser/ui/browser_list.h"
  24 #include "chrome/common/chrome_paths.h"
  25 #include "chrome/common/pref_names.h"
  26 #include "chrome/test/base/testing_profile.h"
  27 #include "components/signin/core/browser/signin_manager.h"
  28 #include "content/public/test/test_browser_thread_bundle.h"
  29 #include "content/public/test/test_utils.h"
  30 #include "testing/gtest/include/gtest/gtest.h"
  31
  32 #if defined(ENABLE_EXTENSIONS)
  33 #include "chrome/browser/extensions/extension_service.h"
  34 #include "chrome/browser/extensions/extension_service_test_base.h"
  35 #include "chrome/browser/extensions/unpacked_installer.h"
  36 #include "chrome/common/extensions/features/feature_channel.h"
  37 #include "extensions/common/extension.h"
  38 #include "extensions/common/extension_builder.h"
  39 #include "extensions/common/manifest_constants.h"
  40 #endif
  41
  42 using content::MessageLoopRunner;
  43
  44 namespace {
  45
  46 void OnProfileDownloadedFail(const base::string16& full_name) {
  47   ASSERT_TRUE(false) << "Profile download should not have succeeded.";
  48 }
  49
  50 // Base class for helper objects that wait for certain events to happen.
  51 // This class will ensure that calls to QuitRunLoop() (triggered by a subclass)
  52 // are balanced with Wait() calls.
  53 class AsyncTestHelper {
  54  public:
  55   void Wait() {
  56     run_loop_->Run();
  57     Reset();
  58   }
  59
  60  protected:
  61   AsyncTestHelper() {
  62     // |quit_called_| will be initialized in Reset().
  63     Reset();
  64   }
  65
  66   ~AsyncTestHelper() {
  67     EXPECT_FALSE(quit_called_);
  68   }
  69
  70   void QuitRunLoop() {
  71     // QuitRunLoop() can not be called more than once between calls to Wait().
  72     ASSERT_FALSE(quit_called_);
  73     quit_called_ = true;
  74     run_loop_->Quit();
  75   }
  76
  77  private:
  78   void Reset() {
  79     quit_called_ = false;
  80     run_loop_.reset(new base::RunLoop);
  81   }
  82
  83   scoped_ptr<base::RunLoop> run_loop_;
  84   bool quit_called_;
  85
  86   DISALLOW_COPY_AND_ASSIGN(AsyncTestHelper);
  87 };
  88
  89 class SupervisedUserURLFilterObserver
  90     : public AsyncTestHelper,
  91       public SupervisedUserURLFilter::Observer {
  92  public:
  93   SupervisedUserURLFilterObserver() : scoped_observer_(this) {}
  94   ~SupervisedUserURLFilterObserver() {}
  95
  96   void Init(SupervisedUserURLFilter* url_filter) {
  97     scoped_observer_.Add(url_filter);
  98   }
  99
 100   // SupervisedUserURLFilter::Observer
 101   void OnSiteListUpdated() override {
 102     QuitRunLoop();
 103   }
 104
 105  private:
 106   ScopedObserver<SupervisedUserURLFilter, SupervisedUserURLFilter::Observer>
 107       scoped_observer_;
 108
 109   DISALLOW_COPY_AND_ASSIGN(SupervisedUserURLFilterObserver);
 110 };
 111
 112 class SiteListObserver : public AsyncTestHelper {
 113  public:
 114   SiteListObserver() {}
 115   ~SiteListObserver() {}
 116
 117   void Init(SupervisedUserWhitelistService* service) {
 118     service->AddSiteListsChangedCallback(base::Bind(
 119         &SiteListObserver::OnSiteListsChanged, base::Unretained(this)));
 120
 121     // The initial call to AddSiteListsChangedCallback will call
 122     // OnSiteListsChanged(), so we balance it out by calling Wait().
 123     Wait();
 124   }
 125
 126   const std::vector<scoped_refptr<SupervisedUserSiteList>>& site_lists() {
 127     return site_lists_;
 128   }
 129
 130   const std::vector<SupervisedUserSiteList::Site>& sites() {
 131     return sites_;
 132   }
 133
 134  private:
 135   void OnSiteListsChanged(
 136       const std::vector<scoped_refptr<SupervisedUserSiteList>>& site_lists) {
 137     site_lists_ = site_lists;
 138     sites_.clear();
 139     for (const scoped_refptr<SupervisedUserSiteList>& site_list : site_lists) {
 140       const std::vector<SupervisedUserSiteList::Site>& sites =
 141           site_list->sites();
 142       sites_.insert(sites_.end(), sites.begin(), sites.end());
 143     }
 144
 145     QuitRunLoop();
 146   }
 147
 148   std::vector<scoped_refptr<SupervisedUserSiteList>> site_lists_;
 149   std::vector<SupervisedUserSiteList::Site> sites_;
 150
 151   DISALLOW_COPY_AND_ASSIGN(SiteListObserver);
 152 };
 153
 154 class AsyncResultHolder {
 155  public:
 156   AsyncResultHolder() : result_(false) {}
 157   ~AsyncResultHolder() {}
 158
 159   void SetResult(bool result) {
 160     result_ = result;
 161     run_loop_.Quit();
 162   }
 163
 164   bool GetResult() {
 165     run_loop_.Run();
 166     return result_;
 167   }
 168
 169  private:
 170   base::RunLoop run_loop_;
 171   bool result_;
 172
 173   DISALLOW_COPY_AND_ASSIGN(AsyncResultHolder);
 174 };
 175
 176 class SupervisedUserServiceTest : public ::testing::Test {
 177  public:
 178   SupervisedUserServiceTest() {}
 179
 180   void SetUp() override {
 181     TestingProfile::Builder builder;
 182     builder.AddTestingFactory(ProfileOAuth2TokenServiceFactory::GetInstance(),
 183                               BuildFakeProfileOAuth2TokenService);
 184     profile_ = builder.Build();
 185     supervised_user_service_ =
 186         SupervisedUserServiceFactory::GetForProfile(profile_.get());
 187   }
 188
 189   void TearDown() override { profile_.reset(); }
 190
 191   ~SupervisedUserServiceTest() override {}
 192
 193  protected:
 194   void AddURLAccessRequest(const GURL& url, AsyncResultHolder* result_holder) {
 195     supervised_user_service_->AddURLAccessRequest(
 196         url, base::Bind(&AsyncResultHolder::SetResult,
 197                         base::Unretained(result_holder)));
 198   }
 199
 200   content::TestBrowserThreadBundle thread_bundle_;
 201   scoped_ptr<TestingProfile> profile_;
 202   SupervisedUserService* supervised_user_service_;
 203 };
 204
 205 }  // namespace
 206
 207 TEST_F(SupervisedUserServiceTest, ChangesIncludedSessionOnChangedSettings) {
 208   supervised_user_service_->Init();
 209   EXPECT_TRUE(supervised_user_service_->IncludesSyncSessionsType());
 210   profile_->GetPrefs()->SetBoolean(prefs::kRecordHistory, false);
 211   EXPECT_FALSE(supervised_user_service_->IncludesSyncSessionsType());
 212 }
 213
 214 // Ensure that the CustodianProfileDownloaderService shuts down cleanly. If no
 215 // DCHECK is hit when the service is destroyed, this test passed.
 216 TEST_F(SupervisedUserServiceTest, ShutDownCustodianProfileDownloader) {
 217   CustodianProfileDownloaderService* downloader_service =
 218       CustodianProfileDownloaderServiceFactory::GetForProfile(profile_.get());
 219
 220   // Emulate being logged in, then start to download a profile so a
 221   // ProfileDownloader gets created.
 222   SigninManagerFactory::GetForProfile(profile_.get())->
 223       SetAuthenticatedAccountInfo("12345", "Logged In");
 224   downloader_service->DownloadProfile(base::Bind(&OnProfileDownloadedFail));
 225 }
 226
 227 namespace {
 228
 229 class MockPermissionRequestCreator : public PermissionRequestCreator {
 230  public:
 231   MockPermissionRequestCreator() : enabled_(false) {}
 232   ~MockPermissionRequestCreator() override {}
 233
 234   void set_enabled(bool enabled) {
 235     enabled_ = enabled;
 236   }
 237
 238   const std::vector<GURL>& requested_urls() const {
 239     return requested_urls_;
 240   }
 241
 242   void AnswerRequest(size_t index, bool result) {
 243     ASSERT_LT(index, requested_urls_.size());
 244     callbacks_[index].Run(result);
 245     callbacks_.erase(callbacks_.begin() + index);
 246     requested_urls_.erase(requested_urls_.begin() + index);
 247   }
 248
 249  private:
 250   // PermissionRequestCreator:
 251   bool IsEnabled() const override { return enabled_; }
 252
 253   void CreateURLAccessRequest(const GURL& url_requested,
 254                               const SuccessCallback& callback) override {
 255     ASSERT_TRUE(enabled_);
 256     requested_urls_.push_back(url_requested);
 257     callbacks_.push_back(callback);
 258   }
 259
 260   void CreateExtensionUpdateRequest(const std::string& id,
 261                                     const SuccessCallback& callback) override {
 262     FAIL();
 263   }
 264
 265   bool enabled_;
 266   std::vector<GURL> requested_urls_;
 267   std::vector<SuccessCallback> callbacks_;
 268
 269   DISALLOW_COPY_AND_ASSIGN(MockPermissionRequestCreator);
 270 };
 271
 272 }  // namespace
 273
 274 TEST_F(SupervisedUserServiceTest, CreatePermissionRequest) {
 275   GURL url("http://www.example.com");
 276
 277   // Without any permission request creators, it should be disabled, and any
 278   // AddURLAccessRequest() calls should fail.
 279   EXPECT_FALSE(supervised_user_service_->AccessRequestsEnabled());
 280   {
 281     AsyncResultHolder result_holder;
 282     AddURLAccessRequest(url, &result_holder);
 283     EXPECT_FALSE(result_holder.GetResult());
 284   }
 285
 286   // Add a disabled permission request creator. This should not change anything.
 287   MockPermissionRequestCreator* creator = new MockPermissionRequestCreator;
 288   supervised_user_service_->AddPermissionRequestCreator(
 289       make_scoped_ptr(creator));
 290
 291   EXPECT_FALSE(supervised_user_service_->AccessRequestsEnabled());
 292   {
 293     AsyncResultHolder result_holder;
 294     AddURLAccessRequest(url, &result_holder);
 295     EXPECT_FALSE(result_holder.GetResult());
 296   }
 297
 298   // Enable the permission request creator. This should enable permission
 299   // requests and queue them up.
 300   creator->set_enabled(true);
 301   EXPECT_TRUE(supervised_user_service_->AccessRequestsEnabled());
 302   {
 303     AsyncResultHolder result_holder;
 304     AddURLAccessRequest(url, &result_holder);
 305     ASSERT_EQ(1u, creator->requested_urls().size());
 306     EXPECT_EQ(url.spec(), creator->requested_urls()[0].spec());
 307
 308     creator->AnswerRequest(0, true);
 309     EXPECT_TRUE(result_holder.GetResult());
 310   }
 311
 312   {
 313     AsyncResultHolder result_holder;
 314     AddURLAccessRequest(url, &result_holder);
 315     ASSERT_EQ(1u, creator->requested_urls().size());
 316     EXPECT_EQ(url.spec(), creator->requested_urls()[0].spec());
 317
 318     creator->AnswerRequest(0, false);
 319     EXPECT_FALSE(result_holder.GetResult());
 320   }
 321
 322   // Add a second permission request creator.
 323   MockPermissionRequestCreator* creator_2 = new MockPermissionRequestCreator;
 324   creator_2->set_enabled(true);
 325   supervised_user_service_->AddPermissionRequestCreator(
 326       make_scoped_ptr(creator_2));
 327
 328   {
 329     AsyncResultHolder result_holder;
 330     AddURLAccessRequest(url, &result_holder);
 331     ASSERT_EQ(1u, creator->requested_urls().size());
 332     EXPECT_EQ(url.spec(), creator->requested_urls()[0].spec());
 333
 334     // Make the first creator succeed. This should make the whole thing succeed.
 335     creator->AnswerRequest(0, true);
 336     EXPECT_TRUE(result_holder.GetResult());
 337   }
 338
 339   {
 340     AsyncResultHolder result_holder;
 341     AddURLAccessRequest(url, &result_holder);
 342     ASSERT_EQ(1u, creator->requested_urls().size());
 343     EXPECT_EQ(url.spec(), creator->requested_urls()[0].spec());
 344
 345     // Make the first creator fail. This should fall back to the second one.
 346     creator->AnswerRequest(0, false);
 347     ASSERT_EQ(1u, creator_2->requested_urls().size());
 348     EXPECT_EQ(url.spec(), creator_2->requested_urls()[0].spec());
 349
 350     // Make the second creator succeed, which will make the whole thing succeed.
 351     creator_2->AnswerRequest(0, true);
 352     EXPECT_TRUE(result_holder.GetResult());
 353   }
 354 }
 355
 356 #if defined(ENABLE_EXTENSIONS)
 357 class SupervisedUserServiceExtensionTestBase
 358     : public extensions::ExtensionServiceTestBase {
 359  public:
 360   explicit SupervisedUserServiceExtensionTestBase(bool is_supervised)
 361       : is_supervised_(is_supervised),
 362         channel_(chrome::VersionInfo::CHANNEL_DEV) {}
 363   ~SupervisedUserServiceExtensionTestBase() override {}
 364
 365   void SetUp() override {
 366     ExtensionServiceTestBase::SetUp();
 367     ExtensionServiceTestBase::ExtensionServiceInitParams params =
 368         CreateDefaultInitParams();
 369     params.profile_is_supervised = is_supervised_;
 370     InitializeExtensionService(params);
 371     SupervisedUserService* service =
 372         SupervisedUserServiceFactory::GetForProfile(profile_.get());
 373     service->Init();
 374     site_list_observer_.Init(service->GetWhitelistService());
 375
 376     SupervisedUserURLFilter* url_filter = service->GetURLFilterForUIThread();
 377     url_filter->SetBlockingTaskRunnerForTesting(
 378         base::ThreadTaskRunnerHandle::Get());
 379     url_filter_observer_.Init(url_filter);
 380
 381     // Wait for the initial update to finish.
 382     url_filter_observer_.Wait();
 383   }
 384
 385   void TearDown() override {
 386     // Flush the message loop, to ensure all posted tasks run.
 387     base::RunLoop().RunUntilIdle();
 388   }
 389
 390  protected:
 391   scoped_refptr<extensions::Extension> MakeThemeExtension() {
 392     scoped_ptr<base::DictionaryValue> source(new base::DictionaryValue());
 393     source->SetString(extensions::manifest_keys::kName, "Theme");
 394     source->Set(extensions::manifest_keys::kTheme, new base::DictionaryValue());
 395     source->SetString(extensions::manifest_keys::kVersion, "1.0");
 396     extensions::ExtensionBuilder builder;
 397     scoped_refptr<extensions::Extension> extension =
 398         builder.SetManifest(source.Pass()).Build();
 399     return extension;
 400   }
 401
 402   scoped_refptr<extensions::Extension> MakeExtension(bool by_custodian) {
 403     scoped_ptr<base::DictionaryValue> manifest = extensions::DictionaryBuilder()
 404       .Set(extensions::manifest_keys::kName, "Extension")
 405       .Set(extensions::manifest_keys::kVersion, "1.0")
 406       .Build();
 407     int creation_flags = extensions::Extension::NO_FLAGS;
 408     if (by_custodian)
 409       creation_flags |= extensions::Extension::WAS_INSTALLED_BY_CUSTODIAN;
 410     extensions::ExtensionBuilder builder;
 411     scoped_refptr<extensions::Extension> extension =
 412         builder.SetManifest(manifest.Pass()).AddFlags(creation_flags).Build();
 413     return extension;
 414   }
 415
 416   bool is_supervised_;
 417   extensions::ScopedCurrentChannel channel_;
 418   SiteListObserver site_list_observer_;
 419   SupervisedUserURLFilterObserver url_filter_observer_;
 420 };
 421
 422 class SupervisedUserServiceExtensionTestUnsupervised
 423     : public SupervisedUserServiceExtensionTestBase {
 424  public:
 425   SupervisedUserServiceExtensionTestUnsupervised()
 426       : SupervisedUserServiceExtensionTestBase(false) {}
 427 };
 428
 429 class SupervisedUserServiceExtensionTest
 430     : public SupervisedUserServiceExtensionTestBase {
 431  public:
 432   SupervisedUserServiceExtensionTest()
 433       : SupervisedUserServiceExtensionTestBase(true) {}
 434 };
 435
 436 TEST_F(SupervisedUserServiceExtensionTest, ExtensionManagementPolicyProvider) {
 437   SupervisedUserService* supervised_user_service =
 438       SupervisedUserServiceFactory::GetForProfile(profile_.get());
 439   ASSERT_TRUE(profile_->IsSupervised());
 440
 441   // Check that a supervised user can install and uninstall a theme.
 442   {
 443     scoped_refptr<extensions::Extension> theme = MakeThemeExtension();
 444
 445     base::string16 error_1;
 446     EXPECT_TRUE(supervised_user_service->UserMayLoad(theme.get(), &error_1));
 447     EXPECT_TRUE(error_1.empty());
 448
 449     base::string16 error_2;
 450     EXPECT_FALSE(
 451         supervised_user_service->MustRemainInstalled(theme.get(), &error_2));
 452     EXPECT_TRUE(error_2.empty());
 453   }
 454
 455   // Now check a different kind of extension; the supervised user should not be
 456   // able to load it.
 457   {
 458     scoped_refptr<extensions::Extension> extension = MakeExtension(false);
 459
 460     base::string16 error;
 461     EXPECT_FALSE(supervised_user_service->UserMayLoad(extension.get(), &error));
 462     EXPECT_FALSE(error.empty());
 463   }
 464
 465   {
 466     // Check that a custodian-installed extension may be loaded, but not
 467     // uninstalled.
 468     scoped_refptr<extensions::Extension> extension = MakeExtension(true);
 469
 470     base::string16 error_1;
 471     EXPECT_TRUE(
 472         supervised_user_service->UserMayLoad(extension.get(), &error_1));
 473     EXPECT_TRUE(error_1.empty());
 474
 475     base::string16 error_2;
 476     EXPECT_TRUE(
 477         supervised_user_service->MustRemainInstalled(extension.get(),
 478                                                      &error_2));
 479     EXPECT_FALSE(error_2.empty());
 480   }
 481
 482 #ifndef NDEBUG
 483   EXPECT_FALSE(supervised_user_service->GetDebugPolicyProviderName().empty());
 484 #endif
 485 }
 486
 487 TEST_F(SupervisedUserServiceExtensionTest, NoContentPacks) {
 488   SupervisedUserService* supervised_user_service =
 489       SupervisedUserServiceFactory::GetForProfile(profile_.get());
 490   SupervisedUserURLFilter* url_filter =
 491       supervised_user_service->GetURLFilterForUIThread();
 492
 493   // ASSERT_EQ instead of ASSERT_TRUE([...].empty()) so that the error
 494   // message contains the size in case of failure.
 495   ASSERT_EQ(0u, site_list_observer_.site_lists().size());
 496
 497   GURL url("http://youtube.com");
 498   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
 499             url_filter->GetFilteringBehaviorForURL(url));
 500 }
 501
 502 TEST_F(SupervisedUserServiceExtensionTest, InstallContentPacks) {
 503   SupervisedUserService* supervised_user_service =
 504       SupervisedUserServiceFactory::GetForProfile(profile_.get());
 505   SupervisedUserURLFilter* url_filter =
 506       supervised_user_service->GetURLFilterForUIThread();
 507
 508   GURL example_url("http://example.com");
 509   GURL moose_url("http://moose.org");
 510   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
 511             url_filter->GetFilteringBehaviorForURL(example_url));
 512
 513   profile_->GetPrefs()->SetInteger(
 514       prefs::kDefaultSupervisedUserFilteringBehavior,
 515       SupervisedUserURLFilter::BLOCK);
 516   EXPECT_EQ(SupervisedUserURLFilter::BLOCK,
 517             url_filter->GetFilteringBehaviorForURL(example_url));
 518
 519   profile_->GetPrefs()->SetInteger(
 520       prefs::kDefaultSupervisedUserFilteringBehavior,
 521       SupervisedUserURLFilter::WARN);
 522   EXPECT_EQ(SupervisedUserURLFilter::WARN,
 523             url_filter->GetFilteringBehaviorForURL(example_url));
 524
 525   // Load a whitelist.
 526   base::FilePath test_data_dir;
 527   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir));
 528   SupervisedUserWhitelistService* whitelist_service =
 529       supervised_user_service->GetWhitelistService();
 530   base::FilePath whitelist_path =
 531       test_data_dir.AppendASCII("whitelists/content_pack/site_list.json");
 532   whitelist_service->LoadWhitelistForTesting("aaaa", whitelist_path);
 533   site_list_observer_.Wait();
 534
 535   ASSERT_EQ(1u, site_list_observer_.site_lists().size());
 536   ASSERT_EQ(3u, site_list_observer_.sites().size());
 537   EXPECT_EQ(base::ASCIIToUTF16("YouTube"), site_list_observer_.sites()[0].name);
 538   EXPECT_EQ(base::ASCIIToUTF16("Homestar Runner"),
 539             site_list_observer_.sites()[1].name);
 540   EXPECT_EQ(base::string16(), site_list_observer_.sites()[2].name);
 541
 542   url_filter_observer_.Wait();
 543   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
 544             url_filter->GetFilteringBehaviorForURL(example_url));
 545   EXPECT_EQ(SupervisedUserURLFilter::WARN,
 546             url_filter->GetFilteringBehaviorForURL(moose_url));
 547
 548   // Load a second whitelist.
 549   whitelist_path =
 550       test_data_dir.AppendASCII("whitelists/content_pack_2/site_list.json");
 551   whitelist_service->LoadWhitelistForTesting("bbbb", whitelist_path);
 552   site_list_observer_.Wait();
 553
 554   ASSERT_EQ(2u, site_list_observer_.site_lists().size());
 555   ASSERT_EQ(4u, site_list_observer_.sites().size());
 556
 557   // The site lists might be returned in any order, so we put them into a set.
 558   std::set<std::string> site_names;
 559   for (const SupervisedUserSiteList::Site& site : site_list_observer_.sites())
 560     site_names.insert(base::UTF16ToUTF8(site.name));
 561   EXPECT_EQ(1u, site_names.count("YouTube"));
 562   EXPECT_EQ(1u, site_names.count("Homestar Runner"));
 563   EXPECT_EQ(1u, site_names.count(std::string()));
 564   EXPECT_EQ(1u, site_names.count("Moose"));
 565
 566   url_filter_observer_.Wait();
 567   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
 568             url_filter->GetFilteringBehaviorForURL(example_url));
 569   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
 570             url_filter->GetFilteringBehaviorForURL(moose_url));
 571
 572   // Unload the first whitelist.
 573   whitelist_service->UnloadWhitelist("aaaa");
 574   site_list_observer_.Wait();
 575
 576   ASSERT_EQ(1u, site_list_observer_.site_lists().size());
 577   ASSERT_EQ(1u, site_list_observer_.sites().size());
 578   EXPECT_EQ(base::ASCIIToUTF16("Moose"), site_list_observer_.sites()[0].name);
 579
 580   url_filter_observer_.Wait();
 581   EXPECT_EQ(SupervisedUserURLFilter::WARN,
 582             url_filter->GetFilteringBehaviorForURL(example_url));
 583   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
 584             url_filter->GetFilteringBehaviorForURL(moose_url));
 585 }
 586 #endif  // defined(ENABLE_EXTENSIONS)