Include referrer chain with inline install requests.

chrome/browser/extensions/webstore_inline_installer_browsertest.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/webstore_inline_installer.h"
 
+#include "base/json/json_reader.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/values.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/extensions/webstore_inline_installer_factory.h"
 #include "chrome/browser/extensions/webstore_installer_test.h"
 #include "chrome/browser/extensions/webstore_standalone_installer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/permissions/permission_set.h"
+#include "net/dns/mock_host_resolver.h"
+#include "net/test/embedded_test_server/http_request.h"
 #include "url/gurl.h"
 
 using content::WebContents;
 
 namespace extensions {
 
 namespace {
 
 const char kWebstoreDomain[] = "cws.com";
 const char kAppDomain[] = "app.com";
 const char kNonAppDomain[] = "nonapp.com";
 const char kTestExtensionId[] = "ecglahbcnmdpdciemllbhojghbkagdje";
 const char kTestDataPath[] = "extensions/api_test/webstore_inline_install";
 const char kCrxFilename[] = "extension.crx";
 
+const char kRedirect1Domain[] = "redirect1.com";
+const char kRedirect2Domain[] = "redirect2.com";
+
 // A struct for letting us store the actual parameters that were passed to
 // the install callback.
 struct InstallResult {
   bool success = false;
   std::string error;
   webstore_install::Result result = webstore_install::RESULT_LAST;
 };
 
 }  // namespace
 
@@ skipping 303 matching lines @@
 }
 
 // Test calling chrome.webstore.install() twice without waiting for the first to
 // finish.
 IN_PROC_BROWSER_TEST_F(WebstoreInlineInstallerTest, DoubleInlineInstallTest) {
   ui_test_utils::NavigateToURL(
       browser(), GenerateTestServerUrl(kAppDomain, "double_install.html"));
   RunTest("runTest");
 }
 
+class WebstoreInlineInstallerRedirectTest : public WebstoreInlineInstallerTest {
+ public:
+  WebstoreInlineInstallerRedirectTest() : cws_request_received_(false) {}
+  ~WebstoreInlineInstallerRedirectTest() override {}
+
+  void SetUpInProcessBrowserTestFixture() override {
+    WebstoreInstallerTest::SetUpInProcessBrowserTestFixture();
+    host_resolver()->AddRule(kRedirect1Domain, "127.0.0.1");
+    host_resolver()->AddRule(kRedirect2Domain, "127.0.0.1");
+  }
+
+  void ProcessServerRequest(
+      const net::test_server::HttpRequest& request) override {
+    if (request.content.find("redirect_chain") != std::string::npos) {
+      cws_request_received_ = true;
+
+      std::unique_ptr<base::Value> contents =
+          base::JSONReader::Read(request.content);
+      ASSERT_EQ(base::Value::Type::DICTIONARY, contents->GetType());
+      cws_request_json_data_ = base::DictionaryValue::From(std::move(contents));
+    }
+  }
+
+  bool cws_request_received_;
+  std::unique_ptr<base::DictionaryValue> cws_request_json_data_;
+};
+
+// Test that an install from a page arrived at via redirects includes the
+// redirect information in the webstore request.
+IN_PROC_BROWSER_TEST_F(WebstoreInlineInstallerRedirectTest,
+                       IncludesRedirectData) {
+  // Hand craft a url that will cause the test server to issue redirects.
+  const std::vector<std::string> redirects = {kRedirect1Domain,
+                                              kRedirect2Domain};
+  net::HostPortPair host_port = embedded_test_server()->host_port_pair();
+  std::string redirect_chain;
+  for (const auto& redirect : redirects) {
+    std::string redirect_url = base::StringPrintf(
+        "http://%s:%d/server-redirect?", redirect.c_str(), host_port.port());
+    redirect_chain += redirect_url;
+  }
+  const GURL install_url =
+      GURL(redirect_chain +
+           GenerateTestServerUrl(kAppDomain, "install.html").spec());
+
+  AutoAcceptInstall();
+  ui_test_utils::NavigateToURL(browser(), install_url);
+  RunTest("runTest");
+
+  EXPECT_TRUE(cws_request_received_);
+  ASSERT_NE(nullptr, cws_request_json_data_);
+
+  base::ListValue* redirect_list = nullptr;
+  cws_request_json_data_->GetList("redirect_chain", &redirect_list);
+  ASSERT_NE(nullptr, redirect_list);
+
+  // Check that the expected domains are in the redirect list.
+  const std::vector<std::string> expected_redirect_domains = {
+      kRedirect1Domain, kRedirect2Domain, kAppDomain};
+  ASSERT_EQ(expected_redirect_domains.size(), redirect_list->GetSize());
+  int i = 0;
+  for (const auto& value : *redirect_list) {
+    std::string value_string;
+    ASSERT_TRUE(value->GetAsString(&value_string));
+    GURL redirect_url(value_string);
+    EXPECT_EQ(expected_redirect_domains[i++], redirect_url.host());
+  }
+}
+
 class WebstoreInlineInstallerListenerTest : public WebstoreInlineInstallerTest {
  public:
   WebstoreInlineInstallerListenerTest() {}
   ~WebstoreInlineInstallerListenerTest() override {}
 
  protected:
   void RunTest(const std::string& file_name) {
     AutoAcceptInstall();
     ui_test_utils::NavigateToURL(browser(),
                                  GenerateTestServerUrl(kAppDomain, file_name));
@@ skipping 30 matching lines @@
       WindowOpenDisposition::NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   DCHECK_NE(old_tab_index, browser()->tab_strip_model()->active_index());
   browser()->tab_strip_model()->CloseWebContentsAt(old_tab_index,
                                                    TabStripModel::CLOSE_NONE);
   WebstoreInstallerTest::RunTest("runTest");
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kTestExtensionId));
 }
 
 }  // namespace extensions