Add extensions code to use common updater in components/update_client/

extensions/browser/updater/update_service_browsertest.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 <map>
-#include <string>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/run_loop.h"
-#include "base/strings/stringprintf.h"
-#include "content/public/test/test_browser_thread_bundle.h"
-#include "content/public/test/test_utils.h"
-#include "extensions/browser/api/extensions_api_client.h"
-#include "extensions/browser/extensions_browser_client.h"
-#include "extensions/browser/updater/update_service.h"
-#include "extensions/common/extension_urls.h"
-#include "extensions/shell/test/shell_test.h"
-#include "net/base/escape.h"
-#include "net/http/http_status_code.h"
-#include "net/url_request/test_url_fetcher_factory.h"
-
-namespace extensions {
-
-namespace {
-
-using FakeResponse = std::pair<std::string, net::HttpStatusCode>;
-
-// TODO(rockot): In general there's enough mock-Omaha-noise that this might be
-// better placed into some test library code in //components/update_client.
-FakeResponse CreateFakeUpdateResponse(const std::string& id,
-                                      size_t crx_length) {
-  std::string response_text = base::StringPrintf(
-      "<gupdate xmlns=\"http://www.google.com/update2/response\" "
-      "    protocol=\"2.0\" server=\"prod\">\n"
-      "  <daystart elapsed_days=\"2860\" elapsed_seconds=\"42042\"/>\n"
-      "  <app appid=\"%s\" status=\"ok\">\n"
-      "    <updatecheck codebase=\"%s\" fp=\"0\" hash=\"\" hash_sha256=\"\" "
-      "        size=\"%d\" status=\"ok\" version=\"1\"/>\n"
-      "  </app>\n"
-      "</gupdate>\n",
-      id.c_str(),
-      base::StringPrintf("https://fake-omaha-hostname/%s.crx",
-                         id.c_str()).c_str(),
-      static_cast<int>(crx_length));
-  return std::make_pair(response_text, net::HTTP_OK);
-}
-
-FakeResponse CreateFakeUpdateNotFoundResponse() {
-  return std::make_pair(
-      std::string(
-          "<gupdate xmlns=\"http://www.google.com/update2/response\" "
-          "         protocol=\"2.0\" server=\"prod\">\n"
-          "  <daystart elapsed_days=\"4242\" elapsed_seconds=\"42042\"/>\n"
-          "  <app appid=\"\" status=\"error-invalidAppId\">\n"
-          "</gupdate>"),
-      net::HTTP_OK);
-}
-
-bool ExtractKeyValueFromComponent(const std::string& component_str,
-                                  const std::string& target_key,
-                                  std::string* extracted_value) {
-  url::Component component(0, static_cast<int>(component_str.length()));
-  url::Component key, value;
-  while (url::ExtractQueryKeyValue(component_str.c_str(), &component, &key,
-                                   &value)) {
-    if (target_key == component_str.substr(key.begin, key.len)) {
-      *extracted_value = component_str.substr(value.begin, value.len);
-      return true;
-    }
-  }
-  return false;
-}
-
-// This extracts an extension ID from an Omaha update query. Queries have the
-// form https://foo/bar/update?x=id%3Dabcdefghijklmnopqrstuvwxyzaaaaaa%26...
-// This function extracts the 'x' query parameter (e.g. "id%3Dabcdef...."),
-// unescapes its value (to become e.g., "id=abcdef...", and then extracts the
-// 'id' value from the result (e.g. "abcdef...").
-bool ExtractIdFromUpdateQuery(const std::string& query_str, std::string* id) {
-  std::string data_string;
-  if (!ExtractKeyValueFromComponent(query_str, "x", &data_string))
-    return false;
-  data_string = net::UnescapeURLComponent(data_string,
-                                          net::UnescapeRule::URL_SPECIAL_CHARS);
-  if (!ExtractKeyValueFromComponent(data_string, "id", id))
-    return false;
-  EXPECT_EQ(32u, id->size());
-  return true;
-}
-
-void ExpectDownloadSuccess(const base::Closure& continuation, bool success) {
-  EXPECT_TRUE(success) << "Download failed.";
-  continuation.Run();
-}
-
-class FakeUpdateURLFetcherFactory : public net::URLFetcherFactory {
- public:
-  ~FakeUpdateURLFetcherFactory() override {}
-
-  void RegisterFakeExtension(const std::string& id,
-                             const std::string& contents) {
-    CHECK_EQ(32u, id.size());
-    fake_extensions_.insert(std::make_pair(id, contents));
-  }
-
-  // net::URLFetcherFactory:
-  scoped_ptr<net::URLFetcher> CreateURLFetcher(
-      int id,
-      const GURL& url,
-      net::URLFetcher::RequestType request_type,
-      net::URLFetcherDelegate* delegate) override {
-    if (url.spec().find(extension_urls::GetWebstoreUpdateUrl().spec()) == 0) {
-      // Handle fake Omaha requests.
-      return CreateUpdateManifestFetcher(url, delegate);
-    } else if (url.spec().find("https://fake-omaha-hostname") == 0) {
-      // Handle a fake CRX request.
-      return CreateCrxFetcher(url, delegate);
-    }
-    NOTREACHED();
-    return nullptr;
-  }
-
- private:
-  scoped_ptr<net::URLFetcher> CreateUpdateManifestFetcher(
-      const GURL& url,
-      net::URLFetcherDelegate* delegate) {
-    // If we have a fake CRX for the ID, return a fake update blob for it.
-    // Otherwise return an invalid-ID response.
-    FakeResponse response;
-    std::string extension_id;
-    if (!ExtractIdFromUpdateQuery(url.query(), &extension_id)) {
-      response = CreateFakeUpdateNotFoundResponse();
-    } else {
-      const auto& iter = fake_extensions_.find(extension_id);
-      if (iter == fake_extensions_.end())
-        response = CreateFakeUpdateNotFoundResponse();
-      else
-        response = CreateFakeUpdateResponse(extension_id, iter->second.size());
-    }
-    return scoped_ptr<net::URLFetcher>(
-        new net::FakeURLFetcher(url, delegate, response.first, response.second,
-                                net::URLRequestStatus::SUCCESS));
-  }
-
-  scoped_ptr<net::URLFetcher> CreateCrxFetcher(
-      const GURL& url,
-      net::URLFetcherDelegate* delegate) {
-    FakeResponse response;
-    std::string extension_id = url.path().substr(1, 32);
-    const auto& iter = fake_extensions_.find(extension_id);
-    if (iter == fake_extensions_.end())
-      response = std::make_pair(std::string(), net::HTTP_NOT_FOUND);
-    else
-      response = std::make_pair(iter->second, net::HTTP_OK);
-    net::TestURLFetcher* fetcher =
-        new net::FakeURLFetcher(url, delegate, response.first, response.second,
-                                net::URLRequestStatus::SUCCESS);
-    fetcher->SetResponseFilePath(base::FilePath::FromUTF8Unsafe(url.path()));
-    return scoped_ptr<net::URLFetcher>(fetcher);
-  }
-
-  std::map<std::string, std::string> fake_extensions_;
-};
-
-}  // namespace
-
-class UpdateServiceTest : public AppShellTest {
- public:
-  UpdateServiceTest() {}
-  ~UpdateServiceTest() override {}
-
-  void SetUpOnMainThread() override {
-    AppShellTest::SetUpOnMainThread();
-
-    update_service_ = UpdateService::Get(browser_context());
-
-    default_url_fetcher_factory_.reset(new FakeUpdateURLFetcherFactory());
-    url_fetcher_factory_.reset(
-        new net::FakeURLFetcherFactory(default_url_fetcher_factory_.get()));
-  }
-
- protected:
-  void RegisterFakeExtension(const std::string& id,
-                             const std::string& crx_contents) {
-    default_url_fetcher_factory_->RegisterFakeExtension(id, crx_contents);
-  }
-
-  UpdateService* update_service() const { return update_service_; }
-
- private:
-  scoped_ptr<FakeUpdateURLFetcherFactory> default_url_fetcher_factory_;
-  scoped_ptr<net::FakeURLFetcherFactory> url_fetcher_factory_;
-
-  UpdateService* update_service_;
-};
-
-IN_PROC_BROWSER_TEST_F(UpdateServiceTest, DownloadAndInstall) {
-  const char kCrxId[] = "abcdefghijklmnopqrstuvwxyzaaaaaa";
-  const char kCrxContents[] = "Hello, world!";
-  RegisterFakeExtension(kCrxId, kCrxContents);
-
-  base::RunLoop run_loop;
-  update_service()->DownloadAndInstall(
-      kCrxId, base::Bind(ExpectDownloadSuccess, run_loop.QuitClosure()));
-  run_loop.Run();
-}
-
-}  // namespace extensions