Adds Lo-Fi fallback support for new Data Reduction Proxy protocol.

content/renderer/previews_state_helper.cc

+// Copyright 2017 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 "content/renderer/previews_state_helper.h"
+
+#include <string>
+
+#include "base/macros.h"
+#include "base/strings/string_piece.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "third_party/WebKit/public/platform/WebString.h"
+
+namespace content {
+
+namespace {
+
+// Chrome Proxy Previews header and directives.
+const char kChromeProxyHeader[] = "chrome-proxy";
+const char kChromeProxyContentTransformHeader[] =
+    "chrome-proxy-content-transform";
+const char kChromeProxyPagePoliciesDirective[] = "page-policies";
+const char kChromeProxyEmptyImageDirective[] = "empty-image";
+const char kChromeProxyLitePageDirective[] = "lite-page";
+
+bool HasEmptyImageDirective(const blink::WebURLResponse& web_url_response) {
+  std::string chrome_proxy_value =
+      web_url_response
+          .HttpHeaderField(blink::WebString::FromUTF8(kChromeProxyHeader))
+          .Utf8();
+  for (const auto& directive :
+       base::SplitStringPiece(chrome_proxy_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,
+                                base::SPLIT_WANT_NONEMPTY)) {
+      if (base::LowerCaseEqualsASCII(policy, kChromeProxyEmptyImageDirective)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+}  // namespace
+
+PreviewsState UpdatePreviewsStateFromMainFrameResponse(
+    PreviewsState original_state,
+    const blink::WebURLResponse& web_url_response) {
+  if (original_state == PREVIEWS_UNSPECIFIED) {
+    return PREVIEWS_OFF;
+  }
+
+  // Don't update the state if server previews were not enabled.
+  if (!(original_state & SERVER_LITE_PAGE_ON)) {
+    return original_state;
+  }
+
+  // At this point, this is a proxy main frame response for which the
+  // PreviewsState needs to be updated from what was enabled/accepted by the
+  // client to what the client should actually do based on the server response.
+
+  PreviewsState updated_state = original_state;
+
+  // Clear the Lite Page bit if Lite Page transformation did not occur.
+  if (web_url_response
+          .HttpHeaderField(
+              blink::WebString::FromUTF8(kChromeProxyContentTransformHeader))
+          .Utf8() != kChromeProxyLitePageDirective) {
+    updated_state &= ~(SERVER_LITE_PAGE_ON);
+  }
+
+  // Determine whether to keep or clear Lo-Fi bits. We need to receive the
+  // empty-image policy directive and have SERVER_LOFI_ON in order to retain
+  // Lo-Fi bits.
+  if (!(original_state & SERVER_LOFI_ON)) {

[RyanSturm, 2017/06/09 17:59:03]

What about HTTPS pages? Would client lofi be allowed for HTTPS pages (would
server lofi be allowed for HTTPS pages)?

Asking because I don't know :)

[dougarnett, 2017/06/09 18:39:18]

HTTPS pages should not reach here (return at line 65 because SERVER_LITE_PAGE_ON
bit not set) => so client LoFi not affected here for HTTPS (so if enabled, will
happen). 

We don't have any support (nor definition as far as I know) for server LoFi on
HTTPS pages but we should raise with Scott. It may be good topic to visit later
if we see meaningful opportunity.  

[RyanSturm, 2017/06/09 18:41:33]

I see, thanks!

[sclittle, 2017/06/09 19:33:11]

Client LoFi will automatically handle all images (regardless of http:// or
https://) on https:// pages if Server LoFi isn't enabled, plus http:// images on
https:// pages should be extremely rare, so this should just be fine.

+    // Server Lo-Fi not enabled so ensure Client Lo-Fi off for this request.
+    updated_state &= ~(CLIENT_LOFI_ON);
+  } else if (!HasEmptyImageDirective(web_url_response)) {
+    updated_state &= ~(SERVER_LOFI_ON | CLIENT_LOFI_ON);
+  }
+
+  // If we are left with no previews bits set, return the off state.
+  if (updated_state == PREVIEWS_UNSPECIFIED) {
+    return PREVIEWS_OFF;
+  }
+
+  return updated_state;
+}
+
+}  // namespace content