Create a content::UrlFetcher interface that lives in content/public/common and convert users to i...

chrome/browser/extensions/extension_updater_unittest.cc

 // Copyright (c) 2011 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 <map>
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 334 matching lines @@
     // Disable blacklist checks (tested elsewhere) so that we only see the
     // update HTTP request.
     updater.set_blacklist_checks_enabled(false);
 
     // Tell the update that it's time to do update checks.
     SimulateTimerFired(&updater);
 
     // Get the url our mock fetcher was asked to fetch.
     TestURLFetcher* fetcher =
         factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
-    const GURL& url = fetcher->original_url();
+    const GURL& url = fetcher->GetOriginalUrl();
     EXPECT_FALSE(url.is_empty());
     EXPECT_TRUE(url.is_valid());
     EXPECT_TRUE(url.SchemeIs("http"));
     EXPECT_EQ("foo.com", url.host());
     EXPECT_EQ("/bar", url.path());
 
     // Validate the extension request parameters in the query. It should
     // look something like "?x=id%3D<id>%26v%3D<version>%26uc".
     EXPECT_TRUE(url.has_query());
     std::vector<std::string> parts;
@@ skipping 29 matching lines @@
         service.profile(), 60*60*24);
     updater.Start();
 
     // Tell the updater that it's time to do update checks.
     SimulateTimerFired(&updater);
 
     // Get the url our mock fetcher was asked to fetch.
     TestURLFetcher* fetcher =
         factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
     ASSERT_FALSE(fetcher == NULL);
-    const GURL& url = fetcher->original_url();
+    const GURL& url = fetcher->GetOriginalUrl();
 
     EXPECT_FALSE(url.is_empty());
     EXPECT_TRUE(url.is_valid());
     EXPECT_TRUE(url.SchemeIs("https"));
     EXPECT_EQ("clients2.google.com", url.host());
     EXPECT_EQ("/service/update2/crx", url.path());
 
     // Validate the extension request parameters in the query. It should
     // look something like "?x=id%3D<id>%26v%3D<version>%26uc".
     EXPECT_TRUE(url.has_query());
@@ skipping 180 matching lines @@
     ManifestFetchData::PingData zeroDays(0, 0);
     fetch1->AddExtension("1111", "1.0", zeroDays, kEmptyUpdateUrlData);
     fetch2->AddExtension("12345", "2.0", kNeverPingedData,
                          kEmptyUpdateUrlData);
     updater.StartUpdateCheck(fetch1);
     updater.StartUpdateCheck(fetch2);
 
     std::string invalid_xml = "invalid xml";
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
-    EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
+    EXPECT_TRUE(fetcher->GetLoadFlags() == expected_load_flags);
 
     fetcher->set_url(url1);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(200);
     fetcher->SetResponseString(invalid_xml);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     // Now that the first request is complete, make sure the second one has
     // been started.
     const std::string kValidXml =
         "<?xml version='1.0' encoding='UTF-8'?>"
         "<gupdate xmlns='http://www.google.com/update2/response'"
         "                protocol='2.0'>"
         " <app appid='12345'>"
         "  <updatecheck codebase='http://example.com/extension_1.2.3.4.crx'"
         "               version='1.2.3.4' prodversionmin='2.0.143.0' />"
         " </app>"
         "</gupdate>";
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
-    EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
+    EXPECT_TRUE(fetcher->GetLoadFlags() == expected_load_flags);
 
     fetcher->set_url(url2);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(200);
     fetcher->SetResponseString(kValidXml);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     // This should run the manifest parsing, then we want to make sure that our
     // service was called with GetExtensionById with the matching id from
     // kValidXml.
@@ skipping 43 matching lines @@
           id,
           PendingExtensionInfo(test_url, &ShouldAlwaysInstall, kIsFromSync,
                                kInstallSilently,
                                Extension::INTERNAL));
     }
 
     // Call back the ExtensionUpdater with a 200 response and some test data
     FilePath extension_file_path(FILE_PATH_LITERAL("/whatever"));
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
-    EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
+    EXPECT_TRUE(fetcher->GetLoadFlags() == expected_load_flags);
 
     fetcher->set_url(test_url);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(200);
     fetcher->SetResponseFilePath(extension_file_path);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     file_thread.Stop();
     ui_loop.RunAllPending();
 
@@ skipping 33 matching lines @@
         "2CE109E9D0FAF820B2434E166297934E6177B65AB9951DBC3E204CAD4689B39C";
 
     std::string version = "0.0.1";
     updater.FetchUpdatedExtension(id, test_url, hash, version);
 
     // Call back the ExtensionUpdater with a 200 response and some test data.
     std::string extension_data("aaabbb");
 
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
-    EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
+    EXPECT_TRUE(fetcher->GetLoadFlags() == expected_load_flags);
 
     fetcher->set_url(test_url);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(200);
     fetcher->SetResponseString(extension_data);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     message_loop.RunAllPending();
 
     // The updater should have called extension service to process the
@@ skipping 38 matching lines @@
     std::string version2 = "0.1";
     // Start two fetches
     updater.FetchUpdatedExtension(id1, url1, hash1, version1);
     updater.FetchUpdatedExtension(id2, url2, hash2, version2);
 
     // Make the first fetch complete.
     FilePath extension_file_path(FILE_PATH_LITERAL("/whatever"));
 
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
-    EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
+    EXPECT_TRUE(fetcher->GetLoadFlags() == expected_load_flags);
 
     // We need some CrxInstallers, and CrxInstallers require a real
     // ExtensionService.  Create one on the testing profile.  Any action
     // the CrxInstallers take is on the testing profile's extension
     // service, not on our mock |service|.  This allows us to fake
     // the CrxInstaller actions we want.
     TestingProfile profile;
     profile.CreateExtensionService(
         CommandLine::ForCurrentProcess(),
         FilePath(),
@@ skipping 28 matching lines @@
     EXPECT_FALSE(tmpfile_path.empty());
     EXPECT_EQ(id1, service.extension_id());
     EXPECT_EQ(url1, service.download_url());
     message_loop.RunAllPending();
 
     // Make sure the second fetch finished and asked the service to do an
     // update.
     FilePath extension_file_path2(FILE_PATH_LITERAL("/whatever2"));
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
-    EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
+    EXPECT_TRUE(fetcher->GetLoadFlags() == expected_load_flags);
 
     fetcher->set_url(url2);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(200);
     fetcher->SetResponseFilePath(extension_file_path2);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     message_loop.RunAllPending();
 
     if (updates_start_running) {
       EXPECT_TRUE(updater.crx_install_is_running_);
@@ skipping 117 matching lines @@
     updater.Start();
     updater.set_blacklist_checks_enabled(false);
 
     // Make the updater do manifest fetching, and note the urls it tries to
     // fetch.
     std::vector<GURL> fetched_urls;
     updater.CheckNow();
     TestURLFetcher* fetcher =
       factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
-    fetched_urls.push_back(fetcher->original_url());
+    fetched_urls.push_back(fetcher->GetOriginalUrl());
 
     fetcher->set_url(fetched_urls[0]);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(500);
     fetcher->SetResponseString("");
     fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
-    fetched_urls.push_back(fetcher->original_url());
+    fetched_urls.push_back(fetcher->GetOriginalUrl());
 
     // The urls could have been fetched in either order, so use the host to
     // tell them apart and note the query each used.
     std::string url1_query;
     std::string url2_query;
     if (fetched_urls[0].host() == url1.host()) {
       url1_query = fetched_urls[0].query();
       url2_query = fetched_urls[1].query();
     } else if (fetched_urls[0].host() == url2.host()) {
       url1_query = fetched_urls[1].query();
@@ skipping 248 matching lines @@
 
 // TODO(asargent) - (http://crbug.com/12780) add tests for:
 // -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