Adds Server Previews protocol UMA plus UMA for not accepting previews

components/data_reduction_proxy/core/common/data_reduction_proxy_headers.cc

Index: components/data_reduction_proxy/core/common/data_reduction_proxy_headers.cc
diff --git a/components/data_reduction_proxy/core/common/data_reduction_proxy_headers.cc b/components/data_reduction_proxy/core/common/data_reduction_proxy_headers.cc
index 52cf1328dd087e952e599e1df148d8ee8fb3c09a..473bebd0452260e0b7e3e4469d86f45c92663cf0 100644
--- a/components/data_reduction_proxy/core/common/data_reduction_proxy_headers.cc
+++ b/components/data_reduction_proxy/core/common/data_reduction_proxy_headers.cc
@@ -42,6 +42,7 @@ const char kEmptyImageDirective[] = "empty-image";
 const char kLitePageDirective[] = "lite-page";
 const char kCompressedVideoDirective[] = "compressed-video";
 const char kIdentityDirective[] = "identity";
+const char kChromeProxyPagePoliciesDirective[] = "page-policies";
 
 // The legacy Chrome-Proxy response header directive for LoFi images.
 const char kLegacyChromeProxyLoFiResponseDirective[] = "q=low";
@@ -120,6 +121,30 @@ bool HasURLRedirectCycle(const std::vector<GURL>& url_chain) {
                    url_chain.back()) != url_chain.rend();
 }
 
+data_reduction_proxy::TransformType ParsePagePolicyDirective(
+    const std::string chrome_proxy_header_value) {
+  for (const auto& directive : base::SplitStringPiece(
+           chrome_proxy_header_value, ",", base::TRIM_WHITESPACE,
+           base::SPLIT_WANT_NONEMPTY)) {
+    if (!base::StartsWith(directive, kChromeProxyPagePoliciesDirective,
+                          base::CompareCase::INSENSITIVE_ASCII)) {
+      continue;
+    }
+
+    // Check policy directive for empty-image entry.
+    base::StringPiece page_policies_value = base::StringPiece(directive).substr(
+        arraysize(kChromeProxyPagePoliciesDirective));
+    for (const auto& policy :
+         base::SplitStringPiece(page_policies_value, "|", base::TRIM_WHITESPACE,

[bengr, 2017/06/28 16:45:51]

So you split and return the first one you find. Would it make more sense to
return all policies you find and let the caller verify that only one was
provided and that it was EMPTY_IMAGE?

[dougarnett, 2017/06/28 22:12:38]

I don't think we should support multiple types here until we actually support
more policy types in the code otherwise. The protocol specifies that we ignore
unknown policy directives (that have well formed syntax) so we should also not
try to enforce that only known ones are returned to us.

+                                base::SPLIT_WANT_NONEMPTY)) {
+      if (base::LowerCaseEqualsASCII(policy, kEmptyImageDirective)) {
+        return data_reduction_proxy::TRANSFORM_PAGE_POLICIES_EMPTY_IMAGE;
+      }
+    }
+  }
+  return data_reduction_proxy::TRANSFORM_NONE;
+}
+
 }  // namespace
 
 namespace data_reduction_proxy {
@@ -168,6 +193,50 @@ const char* if_heavy_qualifier() {
   return kIfHeavyQualifier;
 }
 
+TransformType ParseRequestTransform(const net::HttpRequestHeaders& headers) {
+  std::string accept_transform_value;
+  if (!headers.GetHeader(chrome_proxy_accept_transform_header(),
+                         &accept_transform_value)) {
+    return TRANSFORM_NONE;
+  }
+
+  if (base::LowerCaseEqualsASCII(accept_transform_value,
+                                 lite_page_directive())) {
+    return TRANSFORM_LITE_PAGE;
+  } else if (base::LowerCaseEqualsASCII(accept_transform_value,
+                                        empty_image_directive())) {
+    return TRANSFORM_EMPTY_IMAGE;
+  } else if (base::LowerCaseEqualsASCII(accept_transform_value,
+                                        compressed_video_directive())) {
+    return TRANSFORM_COMPRESS_VIDEO;
+  } else {
+    return TRANSFORM_NONE;
+  }
+}
+
+TransformType ParseResponseTransform(const net::HttpResponseHeaders& headers) {
+  std::string content_transform_value;
+  if (!headers.GetNormalizedHeader(chrome_proxy_content_transform_header(),
+                                   &content_transform_value)) {
+    // No content-transform so check for page-policies in chrome-proxy header.
+    std::string chrome_proxy_header_value;
+    if (headers.GetNormalizedHeader(chrome_proxy_header(),
+                                    &chrome_proxy_header_value)) {
+      return ParsePagePolicyDirective(chrome_proxy_header_value);
+    }
+  } else if (base::LowerCaseEqualsASCII(content_transform_value,
+                                        lite_page_directive())) {
+    return TRANSFORM_LITE_PAGE;
+  } else if (base::LowerCaseEqualsASCII(content_transform_value,
+                                        empty_image_directive())) {
+    return TRANSFORM_EMPTY_IMAGE;
+  } else {
+    NOTREACHED() << "Unexpected content transform header: "
+                 << content_transform_value;
+  }
+  return TRANSFORM_NONE;
+}
+
 bool IsEmptyImagePreview(const net::HttpResponseHeaders& headers) {
   return IsPreviewType(headers, kEmptyImageDirective) ||
          headers.HasHeaderValue(kChromeProxyHeader,