Move Sync-specific tests from ExtensionServiceTest into new file

chrome/browser/extensions/extension_service_test_base.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/extensions/extension_service_test_base.h"
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_garbage_collector_factory.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 159 matching lines @@
   InitializeExtensionService(params);
   service_->updater()->Start();
 }
 
 void ExtensionServiceTestBase::ResetThreadBundle(int options) {
   did_reset_thread_bundle_ = true;
   thread_bundle_.reset();
   thread_bundle_.reset(new content::TestBrowserThreadBundle(options));
 }
 
+size_t ExtensionServiceTestBase::GetPrefKeyCount() {
+  const base::DictionaryValue* dict =
+      profile()->GetPrefs()->GetDictionary("extensions.settings");
+  if (!dict) {
+    ADD_FAILURE();
+    return 0;
+  }
+  return dict->size();
+}
+
+void ExtensionServiceTestBase::ValidatePrefKeyCount(size_t count) {
+  EXPECT_EQ(count, GetPrefKeyCount());
+}
+
+testing::AssertionResult ExtensionServiceTestBase::ValidateBooleanPref(
+    const std::string& extension_id,
+    const std::string& pref_path,
+    bool expected_val) {
+  std::string msg = base::StringPrintf("while checking: %s %s == %s",
+                                       extension_id.c_str(), pref_path.c_str(),
+                                       expected_val ? "true" : "false");
+
+  PrefService* prefs = profile()->GetPrefs();
+  const base::DictionaryValue* dict =
+      prefs->GetDictionary("extensions.settings");
+  if (!dict) {
+    return testing::AssertionFailure()
+        << "extension.settings does not exist " << msg;
+  }
+
+  const base::DictionaryValue* pref = NULL;
+  if (!dict->GetDictionary(extension_id, &pref)) {
+    return testing::AssertionFailure()
+        << "extension pref does not exist " << msg;
+  }
+
+  bool val;

[Devlin, 2015/10/28 16:15:22]

nitty nit: initialize val.

[Marc Treib, 2015/10/29 13:27:57]

Done.

+  if (!pref->GetBoolean(pref_path, &val)) {
+    return testing::AssertionFailure()
+        << pref_path << " pref not found " << msg;
+  }
+
+  return expected_val == val
+      ? testing::AssertionSuccess()
+      : testing::AssertionFailure() << "base::Value is incorrect " << msg;
+}
+
+void ExtensionServiceTestBase::ValidateIntegerPref(
+    const std::string& extension_id,
+    const std::string& pref_path,
+    int expected_val) {
+  std::string msg = base::StringPrintf("while checking: %s %s == %s",
+                                       extension_id.c_str(), pref_path.c_str(),
+                                       base::IntToString(expected_val).c_str());
+
+  PrefService* prefs = profile()->GetPrefs();
+  const base::DictionaryValue* dict =
+      prefs->GetDictionary("extensions.settings");
+  ASSERT_TRUE(dict != NULL) << msg;
+  const base::DictionaryValue* pref = NULL;
+  ASSERT_TRUE(dict->GetDictionary(extension_id, &pref)) << msg;
+  EXPECT_TRUE(pref != NULL) << msg;
+  int val;
+  ASSERT_TRUE(pref->GetInteger(pref_path, &val)) << msg;
+  EXPECT_EQ(expected_val, val) << msg;
+}
+
+void ExtensionServiceTestBase::ValidateStringPref(
+    const std::string& extension_id,
+    const std::string& pref_path,
+    const std::string& expected_val) {
+  std::string msg = base::StringPrintf("while checking: %s.manifest.%s == %s",
+                                       extension_id.c_str(), pref_path.c_str(),
+                                       expected_val.c_str());
+
+  const base::DictionaryValue* dict =
+      profile()->GetPrefs()->GetDictionary("extensions.settings");
+  ASSERT_TRUE(dict != NULL) << msg;
+  const base::DictionaryValue* pref = NULL;
+  std::string manifest_path = extension_id + ".manifest";
+  ASSERT_TRUE(dict->GetDictionary(manifest_path, &pref)) << msg;
+  EXPECT_TRUE(pref != NULL) << msg;
+  std::string val;
+  ASSERT_TRUE(pref->GetString(pref_path, &val)) << msg;
+  EXPECT_EQ(expected_val, val) << msg;
+}
+
 void ExtensionServiceTestBase::SetUp() {
   ExtensionErrorReporter::GetInstance()->ClearErrors();
 }
 
 void ExtensionServiceTestBase::SetUpTestCase() {
   // Safe to call multiple times.
   ExtensionErrorReporter::Init(false);  // no noisy errors.
 }
 
 // These are declared in the .cc so that all inheritors don't need to know
@@ skipping 31 matching lines @@
   // interfere with the tests. Those tests that need an external provider
   // will register one specifically.
   service_->ClearProvidersForTesting();
 
 #if defined(OS_CHROMEOS)
   InstallLimiter::Get(profile_.get())->DisableForTest();
 #endif
 }
 
 }  // namespace extensions