Move CrxFile, FileReader, ExtensionResource to src/extensions.

chrome/browser/extensions/updater/extension_updater_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 <list>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 36 matching lines @@
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/omaha_query_params.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/test/test_browser_thread.h"
+#include "extensions/common/id_util.h"
 #include "libxml/globals.h"
 #include "net/base/backoff_entry.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
@@ skipping 189 matching lines @@
   TestExtensionPrefs* const prefs_;
   PendingExtensionManager pending_extension_manager_;
   TestingProfile profile_;
   Blacklist blacklist_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockService);
 };
 
 
-std::string GenerateId(std::string input) {
-  std::string result;
-  EXPECT_TRUE(Extension::GenerateId(input, &result));
-  return result;
-}
-
 bool ShouldInstallExtensionsOnly(const Extension& extension) {
   return extension.GetType() == Manifest::TYPE_EXTENSION;
 }
 
 bool ShouldInstallThemesOnly(const Extension& extension) {
   return extension.is_theme();
 }
 
 bool ShouldAlwaysInstall(const Extension& extension) {
   return true;
 }
 
 // Loads some pending extension records into a pending extension manager.
 void SetupPendingExtensionManagerForTest(
     int count,
     const GURL& update_url,
     PendingExtensionManager* pending_extension_manager) {
   for (int i = 1; i <= count; ++i) {
     PendingExtensionInfo::ShouldAllowInstallPredicate should_allow_install =
         (i % 2 == 0) ? &ShouldInstallThemesOnly : &ShouldInstallExtensionsOnly;
     const bool kIsFromSync = true;
     const bool kInstallSilently = true;
-    std::string id = GenerateId(base::StringPrintf("extension%i", i));
+    std::string id = id_util::GenerateId(base::StringPrintf("extension%i", i));
 
     pending_extension_manager->AddForTesting(
         PendingExtensionInfo(id,
                              update_url,
                              Version(),
                              should_allow_install,
                              kIsFromSync,
                              kInstallSilently,
                              Manifest::INTERNAL));
   }
@@ skipping 429 matching lines @@
     // Check passing an empty list of parse results to DetermineUpdates
     ManifestFetchData fetch_data(GURL("http://localhost/foo"), 0);
     UpdateManifest::Results updates;
     std::vector<int> updateable;
     downloader.DetermineUpdates(fetch_data, updates, &updateable);
     EXPECT_TRUE(updateable.empty());
 
     // Create two updates - expect that DetermineUpdates will return the first
     // one (v1.0 installed, v1.1 available) but not the second one (both
     // installed and available at v2.0).
-    const std::string id1 = GenerateId("1");
-    const std::string id2 = GenerateId("2");
+    const std::string id1 = id_util::GenerateId("1");
+    const std::string id2 = id_util::GenerateId("2");
     fetch_data.AddExtension(id1, "1.0.0.0",
                             &kNeverPingedData, kEmptyUpdateUrlData, "");
     AddParseResult(id1, "1.1",
                    "http://localhost/e1_1.1.crx", &updates);
     fetch_data.AddExtension(id2, "2.0.0.0",
                             &kNeverPingedData, kEmptyUpdateUrlData, "");
     AddParseResult(id2, "2.0.0.0",
                    "http://localhost/e2_2.0.crx", &updates);
 
     EXPECT_CALL(delegate, IsExtensionPending(_)).WillRepeatedly(Return(false));
@@ skipping 872 matching lines @@
 TEST_F(ExtensionUpdaterTest, TestManifestFetchesBuilderAddExtension) {
   net::TestURLFetcherFactory factory;
   MockService service(prefs_.get());
   MockExtensionDownloaderDelegate delegate;
   scoped_ptr<ExtensionDownloader> downloader(
       new ExtensionDownloader(&delegate, service.request_context()));
   EXPECT_EQ(0u, ManifestFetchersCount(downloader.get()));
 
   // First, verify that adding valid extensions does invoke the callbacks on
   // the delegate.
-  std::string id = GenerateId("foo");
+  std::string id = id_util::GenerateId("foo");
   EXPECT_CALL(delegate, GetPingDataForExtension(id, _)).WillOnce(Return(false));
   EXPECT_TRUE(
       downloader->AddPendingExtension(id, GURL("http://example.com/update"),
                                       0));
   downloader->StartAllPending();
   Mock::VerifyAndClearExpectations(&delegate);
   EXPECT_EQ(1u, ManifestFetchersCount(downloader.get()));
 
   // Extensions with invalid update URLs should be rejected.
-  id = GenerateId("foo2");
+  id = id_util::GenerateId("foo2");
   EXPECT_FALSE(
       downloader->AddPendingExtension(id, GURL("http:google.com:foo"), 0));
   downloader->StartAllPending();
   EXPECT_EQ(1u, ManifestFetchersCount(downloader.get()));
 
   // Extensions with empty IDs should be rejected.
   EXPECT_FALSE(downloader->AddPendingExtension("", GURL(), 0));
   downloader->StartAllPending();
   EXPECT_EQ(1u, ManifestFetchersCount(downloader.get()));
 
   // TODO(akalin): Test that extensions with empty update URLs
   // converted from user scripts are rejected.
 
   // Reset the ExtensionDownloader so that it drops the current fetcher.
   downloader.reset(
       new ExtensionDownloader(&delegate, service.request_context()));
   EXPECT_EQ(0u, ManifestFetchersCount(downloader.get()));
 
   // Extensions with empty update URLs should have a default one
   // filled in.
-  id = GenerateId("foo3");
+  id = id_util::GenerateId("foo3");
   EXPECT_CALL(delegate, GetPingDataForExtension(id, _)).WillOnce(Return(false));
   EXPECT_TRUE(downloader->AddPendingExtension(id, GURL(), 0));
   downloader->StartAllPending();
   EXPECT_EQ(1u, ManifestFetchersCount(downloader.get()));
 
   net::TestURLFetcher* fetcher =
       factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
   ASSERT_TRUE(fetcher);
   EXPECT_FALSE(fetcher->GetOriginalURL().is_empty());
 }
@@ skipping 38 matching lines @@
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -malformed update url (empty, file://, has query, has a # fragment, etc.)
 // -An extension gets uninstalled while updates are in progress (so it doesn't
 //  "come back from the dead")
 // -An extension gets manually updated to v3 while we're downloading v2 (ie
 //  you don't get downgraded accidentally)
 // -An update manifest mentions multiple updates
 
 }  // namespace extensions