Include referrer chain with inline install requests.

chrome/browser/extensions/webstore_inline_installer.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 "chrome/browser/extensions/webstore_inline_installer.h"
 
+#include <utility>
+
+#include "base/json/json_writer.h"
 #include "base/strings/stringprintf.h"
+#include "base/values.h"
+#include "chrome/browser/extensions/webstore_data_fetcher.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/exclusive_access/fullscreen_controller.h"
 #include "content/public/browser/navigation_details.h"
+#include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/web_contents.h"
 
 using content::WebContents;
 
 namespace extensions {
 
 const char kInvalidWebstoreResponseError[] =
     "Invalid Chrome Web Store response.";
 const char kNoVerifiedSitesError[] =
     "Inline installs can only be initiated for Chrome Web Store items that "
@@ skipping 66 matching lines @@
     }
   }
   if (!requestor_is_ok) {
     *error = kNotFromVerifiedSitesError;
     return false;
   }
   *error = "";
   return true;
 }
 
+void WebstoreInlineInstaller::StartWebstoreDataRequest(

[Devlin, 2017/01/27 20:31:34]

In the original version of this patch, this used a async history method to get
the redirect chain, so this separation was more necessary.  Now, this is all
sync (and using the navigation entry seems more correct anyway).  With this, I
think we could clean this up a bit.

What if instead of having OnBeforeWebstoreDataRequest() which by default calls
fetcher->Start() we just have a method like
virtual std::string GetJsonPostData()
which by default returns an empty string, and we override it here to return the
redirect chain?  Then we just call that from the base class and assign the post
data if it's non-empty.  That'd get rid of some of the bouncing around here.

[robertshield, 2017/01/28 03:58:48]

Good idea! That's a lot cleaner and makes deriving from
WebstoreStandaloneInstaller much easier. Done.

+    WebstoreDataFetcher* fetcher,
+    const std::vector<GURL> redirect_list) {
+  if (!redirect_list.empty()) {
+    base::DictionaryValue dictionary;
+    dictionary.SetString("id", id());
+    dictionary.SetString("referrer", requestor_url_.spec());
+    std::unique_ptr<base::ListValue> redirect_chain =
+        base::MakeUnique<base::ListValue>();
+    for (const GURL& url : redirect_list) {

[Devlin, 2017/01/27 20:31:34]

Are we worried at all about the size of the redirect chain?  This could be a
large number of large urls...

[robertshield, 2017/01/28 03:58:48]

Good question, I'm not really sure. A estimate of an upper bound is ~2K x 20
(max url size x max redirects) or 40K per POST request. I'll see if an extra max
40K of data, probably much less than this most of the time, would be a concern
(I suspect not). 

+      redirect_chain->AppendString(url.spec());
+    }
+    dictionary.Set("redirect_chain", std::move(redirect_chain));
+
+    std::unique_ptr<std::string> json = base::MakeUnique<std::string>();
+    base::JSONWriter::Write(dictionary, json.get());
+    fetcher->SetJsonPostData(std::move(json));
+  }
+  fetcher->Start();
+}
+
+void WebstoreInlineInstaller::OnBeforeWebstoreDataRequest(
+    WebstoreDataFetcher* fetcher) {
+  content::WebContents* web_contents = GetWebContents();
+
+  std::vector<GURL> redirect_chain;
+  if (web_contents) {
+    content::NavigationController& navigation_controller =
+        web_contents->GetController();
+    content::NavigationEntry* navigation_entry =
+        navigation_controller.GetLastCommittedEntry();
+    if (navigation_entry) {
+      const std::vector<GURL>& temp_redirects =
+          navigation_entry->GetRedirectChain();
+      redirect_chain.assign(temp_redirects.begin(), temp_redirects.end());
+    }
+  }
+  StartWebstoreDataRequest(fetcher, redirect_chain);
+}
+
 bool WebstoreInlineInstaller::CheckRequestorAlive() const {
   // The frame or tab may have gone away - cancel installation in that case.
   return host_ != nullptr && web_contents() != nullptr;
 }
 
 const GURL& WebstoreInlineInstaller::GetRequestorURL() const {
   return requestor_url_;
 }
 
 std::unique_ptr<ExtensionInstallPrompt::Prompt>
@@ skipping 137 matching lines @@
     DLOG(WARNING) << "Could not parse " << verified_site_pattern_spec <<
         " as URL pattern " << parse_result;
     return false;
   }
   verified_site_pattern.SetScheme("*");
 
   return verified_site_pattern.MatchesURL(requestor_url);
 }
 
 }  // namespace extensions