Propagate referrer to new windows (#12397)

* Propagate referrer to new windows

Fixes #9205

* Rearrange -new-window event arguments for backwards-compatibility

* Plumb referrer policy through guest-window-manager

* Document the Referrer structure and its uses

* Add tests for referrer in new windows

* Docs nits

atom/common/native_mate_converters/blink_converter.cc

@@ -481,4 +481,56 @@ v8::Local<v8::Value> Converter<blink::WebCache::ResourceTypeStats>::ToV8(
   return dict.GetHandle();
 }
 
+// static
+v8::Local<v8::Value> Converter<blink::WebReferrerPolicy>::ToV8(
+      v8::Isolate* isolate,
+      const blink::WebReferrerPolicy& in) {
+  switch (in) {
+    case blink::kWebReferrerPolicyDefault:
+      return mate::StringToV8(isolate, "default");
+    case blink::kWebReferrerPolicyAlways:
+      return mate::StringToV8(isolate, "unsafe-url");
+    case blink::kWebReferrerPolicyNoReferrerWhenDowngrade:
+      return mate::StringToV8(isolate, "no-referrer-when-downgrade");
+    case blink::kWebReferrerPolicyNever:
+      return mate::StringToV8(isolate, "no-referrer");
+    case blink::kWebReferrerPolicyOrigin:
+      return mate::StringToV8(isolate, "origin");
+    case blink::kWebReferrerPolicyNoReferrerWhenDowngradeOriginWhenCrossOrigin:
+      return mate::StringToV8(isolate, "strict-origin-when-cross-origin");
+    case blink::kWebReferrerPolicySameOrigin:
+      return mate::StringToV8(isolate, "same-origin");
+    case blink::kWebReferrerPolicyStrictOrigin:
+      return mate::StringToV8(isolate, "strict-origin");
+    default:
+      return mate::StringToV8(isolate, "no-referrer");
+  }
+}
+
+// static
+bool Converter<blink::WebReferrerPolicy>::FromV8(v8::Isolate* isolate,
+      v8::Handle<v8::Value> val, blink::WebReferrerPolicy* out) {
+  std::string policy = base::ToLowerASCII(V8ToString(val));
+  if (policy == "default")
+    *out = blink::kWebReferrerPolicyDefault;
+  else if (policy == "unsafe-url")
+    *out = blink::kWebReferrerPolicyAlways;
+  else if (policy == "no-referrer-when-downgrade")
+    *out = blink::kWebReferrerPolicyNoReferrerWhenDowngrade;
+  else if (policy == "no-referrer")
+    *out = blink::kWebReferrerPolicyNever;
+  else if (policy == "origin")
+    *out = blink::kWebReferrerPolicyOrigin;
+  else if (policy == "strict-origin-when-cross-origin")
+    *out =
+        blink::kWebReferrerPolicyNoReferrerWhenDowngradeOriginWhenCrossOrigin;
+  else if (policy == "same-origin")
+    *out = blink::kWebReferrerPolicySameOrigin;
+  else if (policy == "strict-origin")
+    *out = blink::kWebReferrerPolicyStrictOrigin;
+  else
+    return false;
+  return true;
+}
+
 }  // namespace mate

atom/common/native_mate_converters/blink_converter.h

@@ -119,6 +119,14 @@ struct Converter<blink::WebCache::ResourceTypeStats> {
       const blink::WebCache::ResourceTypeStats& stats);
 };
 
+template<>
+struct Converter<blink::WebReferrerPolicy> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+      const blink::WebReferrerPolicy& in);
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
+                     blink::WebReferrerPolicy* out);
+};
+
 v8::Local<v8::Value> EditFlagsToV8(v8::Isolate* isolate, int editFlags);
 v8::Local<v8::Value> MediaFlagsToV8(v8::Isolate* isolate, int mediaFlags);
 

atom/common/native_mate_converters/content_converter.cc

@@ -318,4 +318,31 @@ bool Converter<content::WebContents*>::FromV8(
   return true;
 }
 
+// static
+v8::Local<v8::Value> Converter<content::Referrer>::ToV8(
+    v8::Isolate* isolate, const content::Referrer& val) {
+  mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
+  dict.Set("url", ConvertToV8(isolate, val.url));
+  dict.Set("policy", ConvertToV8(isolate, val.policy));
+  return mate::ConvertToV8(isolate, dict);
+}
+
+// static
+bool Converter<content::Referrer>::FromV8(
+    v8::Isolate* isolate,
+    v8::Local<v8::Value> val,
+    content::Referrer* out) {
+  mate::Dictionary dict;
+  if (!ConvertFromV8(isolate, val, &dict))
+    return false;
+
+  if (!dict.Get("url", &out->url))
+    return false;
+
+  if (!dict.Get("policy", &out->policy))
+    return false;
+
+  return true;
+}
+
 }  // namespace mate

atom/common/native_mate_converters/content_converter.h

@@ -9,6 +9,7 @@
 
 #include "content/public/browser/permission_type.h"
 #include "content/public/common/menu_item.h"
+#include "content/public/common/referrer.h"
 #include "content/public/common/stop_find_action.h"
 #include "native_mate/converter.h"
 #include "third_party/WebKit/public/platform/modules/permissions/permission_status.mojom.h"
@@ -71,6 +72,14 @@ struct Converter<content::WebContents*> {
                      content::WebContents** out);
 };
 
+template<>
+struct Converter<content::Referrer> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const content::Referrer& val);
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
+                     content::Referrer* out);
+};
+
 }  // namespace mate
 
 #endif  // ATOM_COMMON_NATIVE_MATE_CONVERTERS_CONTENT_CONVERTER_H_