Extensions: Move id_util functions to crx_file component.

chrome/browser/extensions/error_console/error_console_unittest.cc

 // Copyright 2013 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/error_console/error_console.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/common/extensions/features/feature_channel.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
+#include "components/crx_file/id_util.h"
 #include "extensions/browser/extension_error.h"
 #include "extensions/browser/extension_error_test_util.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/feature_switch.h"
-#include "extensions/common/id_util.h"
 #include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
 using error_test_util::CreateNewManifestError;
 using error_test_util::CreateNewRuntimeError;
 
 class ErrorConsoleUnitTest : public testing::Test {
  public:
@@ skipping 89 matching lines @@
   registry->TriggerOnUnloaded(adt, UnloadedExtensionInfo::REASON_DISABLE);
   EXPECT_FALSE(error_console_->enabled());
   EXPECT_FALSE(error_console_->IsEnabledForChromeExtensionsPage());
   EXPECT_FALSE(error_console_->IsEnabledForAppsDeveloperTools());
 }
 
 // Test that errors are successfully reported. This is a simple test, since it
 // is tested more thoroughly in extensions/browser/error_map_unittest.cc
 TEST_F(ErrorConsoleUnitTest, ReportErrors) {
   const size_t kNumTotalErrors = 6;
-  const std::string kId = id_util::GenerateId("id");
+  const std::string kId = crx_file::id_util::GenerateId("id");
   error_console_->set_default_reporting_for_test(ExtensionError::MANIFEST_ERROR,
                                                  true);
   ASSERT_EQ(0u, error_console_->GetErrorsForExtension(kId).size());
 
   for (size_t i = 0; i < kNumTotalErrors; ++i) {
     error_console_->ReportError(
         CreateNewManifestError(kId, base::UintToString(i)));
   }
 
   ASSERT_EQ(kNumTotalErrors, error_console_->GetErrorsForExtension(kId).size());
 }
 
 TEST_F(ErrorConsoleUnitTest, DontStoreErrorsWithoutEnablingType) {
   // Disable default runtime error reporting, and enable default manifest error
   // reporting.
   error_console_->set_default_reporting_for_test(ExtensionError::RUNTIME_ERROR,
                                                  false);
   error_console_->set_default_reporting_for_test(ExtensionError::MANIFEST_ERROR,
                                                  true);
 
-  const std::string kId = id_util::GenerateId("id");
+  const std::string kId = crx_file::id_util::GenerateId("id");
 
   // Try to report a runtime error - it should be ignored.
   error_console_->ReportError(CreateNewRuntimeError(kId, "a"));
   ASSERT_EQ(0u, error_console_->GetErrorsForExtension(kId).size());
 
   // Check that manifest errors are reported successfully.
   error_console_->ReportError(CreateNewManifestError(kId, "b"));
   ASSERT_EQ(1u, error_console_->GetErrorsForExtension(kId).size());
 
   // We should still ignore runtime errors.
   error_console_->ReportError(CreateNewRuntimeError(kId, "c"));
   ASSERT_EQ(1u, error_console_->GetErrorsForExtension(kId).size());
 
   // Enable runtime errors specifically for this extension, and disable the use
   // of the default mask.
   error_console_->SetReportingForExtension(
       kId, ExtensionError::RUNTIME_ERROR, true);
 
   // We should now accept runtime and manifest errors.
   error_console_->ReportError(CreateNewManifestError(kId, "d"));
   ASSERT_EQ(2u, error_console_->GetErrorsForExtension(kId).size());
   error_console_->ReportError(CreateNewRuntimeError(kId, "e"));
   ASSERT_EQ(3u, error_console_->GetErrorsForExtension(kId).size());
 
   // All other extensions should still use the default mask, and ignore runtime
   // errors but report manifest errors.
-  const std::string kId2 = id_util::GenerateId("id2");
+  const std::string kId2 = crx_file::id_util::GenerateId("id2");
   error_console_->ReportError(CreateNewRuntimeError(kId2, "f"));
   ASSERT_EQ(0u, error_console_->GetErrorsForExtension(kId2).size());
   error_console_->ReportError(CreateNewManifestError(kId2, "g"));
   ASSERT_EQ(1u, error_console_->GetErrorsForExtension(kId2).size());
 
   // By reverting to default reporting, we should again allow manifest errors,
   // but not runtime errors.
   error_console_->UseDefaultReportingForExtension(kId);
   error_console_->ReportError(CreateNewManifestError(kId, "h"));
   ASSERT_EQ(4u, error_console_->GetErrorsForExtension(kId).size());
   error_console_->ReportError(CreateNewRuntimeError(kId, "i"));
   ASSERT_EQ(4u, error_console_->GetErrorsForExtension(kId).size());
 }
 
 // Test that we only store errors by default for unpacked extensions, and that
 // assigning a preference to any extension overrides the defaults.
 TEST_F(ErrorConsoleUnitTest, TestDefaultStoringPrefs) {
   // For this, we need actual extensions.
   scoped_refptr<const Extension> unpacked_extension =
       ExtensionBuilder()
-          .SetManifest(DictionaryBuilder().Set("name", "unpacked")
-                                          .Set("version", "0.0.1")
-                                          .Set("manifest_version", 2)
-                                          .Build())
+          .SetManifest(DictionaryBuilder()
+                           .Set("name", "unpacked")
+                           .Set("version", "0.0.1")
+                           .Set("manifest_version", 2)
+                           .Build())
           .SetLocation(Manifest::UNPACKED)
-          .SetID(id_util::GenerateId("unpacked"))
+          .SetID(crx_file::id_util::GenerateId("unpacked"))
           .Build();
   scoped_refptr<const Extension> packed_extension =
       ExtensionBuilder()
-          .SetManifest(DictionaryBuilder().Set("name", "packed")
-                                          .Set("version", "0.0.1")
-                                          .Set("manifest_version", 2)
-                                          .Build())
+          .SetManifest(DictionaryBuilder()
+                           .Set("name", "packed")
+                           .Set("version", "0.0.1")
+                           .Set("manifest_version", 2)
+                           .Build())
           .SetLocation(Manifest::INTERNAL)
-          .SetID(id_util::GenerateId("packed"))
+          .SetID(crx_file::id_util::GenerateId("packed"))
           .Build();
 
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile_.get());
   registry->AddEnabled(unpacked_extension);
   registry->AddEnabled(packed_extension);
 
   // We should start with a clean slate.
   EXPECT_EQ(0u, error_console_->GetErrorsForExtension(
       unpacked_extension->id()).size());
   EXPECT_EQ(0u, error_console_->GetErrorsForExtension(
@@ skipping 40 matching lines @@
   error_console_->ReportError(
       CreateNewRuntimeError(packed_extension->id(), "runtime error 4"));
   EXPECT_EQ(2u,  // We should still have the first two errors.
             error_console_->GetErrorsForExtension(
                 unpacked_extension->id()).size());
   EXPECT_FALSE(error_console_->IsReportingEnabledForExtension(
       unpacked_extension->id()));
 }
 
 }  // namespace extensions