Proper initialization for known_disabled.

chrome/browser/extensions/extension_prefs_unittest.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/extension_prefs_unittest.h"
 
 #include "base/basictypes.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/prefs/mock_pref_change_callback.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_pref_value_map.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/common/chrome_paths.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/test/mock_notification_observer.h"
+#include "extensions/common/extension.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_info.h"
 #include "sync/api/string_ordinal.h"
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
 
 namespace extensions {
@@ skipping 60 matching lines @@
 };
 TEST_F(ExtensionPrefsLastPingDay, LastPingDay) {}
 
 // Tests the GetToolbarOrder/SetToolbarOrder functions.
 class ExtensionPrefsToolbarOrder : public ExtensionPrefsTest {
  public:
   virtual void Initialize() OVERRIDE {
     list_.push_back(prefs_.AddExtensionAndReturnId("1"));
     list_.push_back(prefs_.AddExtensionAndReturnId("2"));
     list_.push_back(prefs_.AddExtensionAndReturnId("3"));
-    std::vector<std::string> before_list = prefs()->GetToolbarOrder();
+    ExtensionIdList before_list = prefs()->GetToolbarOrder();
     EXPECT_TRUE(before_list.empty());
     prefs()->SetToolbarOrder(list_);
   }
 
   virtual void Verify() OVERRIDE {
-    std::vector<std::string> result = prefs()->GetToolbarOrder();
+    ExtensionIdList result = prefs()->GetToolbarOrder();
     ASSERT_EQ(list_, result);
   }
 
  private:
-  std::vector<std::string> list_;
+  ExtensionIdList list_;
 };
 TEST_F(ExtensionPrefsToolbarOrder, ToolbarOrder) {}
 
 // Tests the GetKnownDisabled/SetKnownDisabled functions.
 class ExtensionPrefsKnownDisabled : public ExtensionPrefsTest {
  public:
   virtual void Initialize() OVERRIDE {
+    ExtensionIdSet before_set;
+    EXPECT_FALSE(prefs()->GetKnownDisabled(&before_set));
+    EXPECT_TRUE(before_set.empty());
+
+    // Initialize to an empty list and confirm that GetKnownDisabled() returns
+    // true and an empty list.
+    prefs()->SetKnownDisabled(before_set);
+    EXPECT_TRUE(prefs()->GetKnownDisabled(&before_set));
+    EXPECT_TRUE(before_set.empty());
+
     set_.insert(prefs_.AddExtensionAndReturnId("1"));
     set_.insert(prefs_.AddExtensionAndReturnId("2"));
     set_.insert(prefs_.AddExtensionAndReturnId("3"));
-    std::set<std::string> before_set = prefs()->GetKnownDisabled();
-    EXPECT_TRUE(before_set.empty());
     prefs()->SetKnownDisabled(set_);
   }
 
   virtual void Verify() OVERRIDE {
-    std::set<std::string> result = prefs()->GetKnownDisabled();
+    ExtensionIdSet result;
+    EXPECT_TRUE(prefs()->GetKnownDisabled(&result));
     ASSERT_EQ(set_, result);
   }
 
  private:
-  std::set<std::string> set_;
+  ExtensionIdSet set_;
 };
 TEST_F(ExtensionPrefsKnownDisabled, KnownDisabled) {}
 
 // Tests the IsExtensionDisabled/SetExtensionState functions.
 class ExtensionPrefsExtensionState : public ExtensionPrefsTest {
  public:
   virtual void Initialize() OVERRIDE {
     extension = prefs_.AddExtension("test");
     prefs()->SetExtensionState(extension->id(), Extension::DISABLED);
   }
@@ skipping 620 matching lines @@
   virtual ~ExtensionPrefsBlacklistedExtensions() {}
 
   virtual void Initialize() OVERRIDE {
     extension_a_ = prefs_.AddExtension("a");
     extension_b_ = prefs_.AddExtension("b");
     extension_c_ = prefs_.AddExtension("c");
   }
 
   virtual void Verify() OVERRIDE {
     {
-      std::set<std::string> ids;
+      ExtensionIdSet ids;
       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
     }
     prefs()->SetExtensionBlacklisted(extension_a_->id(), true);
     {
-      std::set<std::string> ids;
+      ExtensionIdSet ids;
       ids.insert(extension_a_->id());
       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
     }
     prefs()->SetExtensionBlacklisted(extension_b_->id(), true);
     prefs()->SetExtensionBlacklisted(extension_c_->id(), true);
     {
-      std::set<std::string> ids;
+      ExtensionIdSet ids;
       ids.insert(extension_a_->id());
       ids.insert(extension_b_->id());
       ids.insert(extension_c_->id());
       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
     }
     prefs()->SetExtensionBlacklisted(extension_a_->id(), false);
     {
-      std::set<std::string> ids;
+      ExtensionIdSet ids;
       ids.insert(extension_b_->id());
       ids.insert(extension_c_->id());
       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
     }
     prefs()->SetExtensionBlacklisted(extension_b_->id(), false);
     prefs()->SetExtensionBlacklisted(extension_c_->id(), false);
     {
-      std::set<std::string> ids;
+      ExtensionIdSet ids;
       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
     }
 
     // The interesting part: make sure that we're cleaning up after ourselves
     // when we're storing *just* the fact that the extension is blacklisted.
     std::string arbitrary_id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 
     prefs()->SetExtensionBlacklisted(arbitrary_id, true);
     prefs()->SetExtensionBlacklisted(extension_a_->id(), true);
 
     // (And make sure that the acknowledged bit is also cleared).
     prefs()->AcknowledgeBlacklistedExtension(arbitrary_id);
 
     EXPECT_TRUE(prefs()->GetExtensionPref(arbitrary_id));
     {
-      std::set<std::string> ids;
+      ExtensionIdSet ids;
       ids.insert(arbitrary_id);
       ids.insert(extension_a_->id());
       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
     }
     prefs()->SetExtensionBlacklisted(arbitrary_id, false);
     prefs()->SetExtensionBlacklisted(extension_a_->id(), false);
     EXPECT_FALSE(prefs()->GetExtensionPref(arbitrary_id));
     {
-      std::set<std::string> ids;
+      ExtensionIdSet ids;
       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
     }
   }
 
  private:
   scoped_refptr<const Extension> extension_a_;
   scoped_refptr<const Extension> extension_b_;
   scoped_refptr<const Extension> extension_c_;
 };
 TEST_F(ExtensionPrefsBlacklistedExtensions,
        ExtensionPrefsBlacklistedExtensions) {}
 
 }  // namespace extensions