[Sync] Finch Experiment : Enable compression between sync client and server

sync/internal_api/http_bridge_unittest.cc

 // Copyright 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 "base/metrics/field_trial.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/test/mock_entropy_provider.h"
 #include "base/threading/thread.h"
 #include "net/http/http_response_headers.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_test_util.h"
 #include "sync/internal_api/public/base/cancelation_signal.h"
 #include "sync/internal_api/public/http_bridge.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 namespace {
 // TODO(timsteele): Should use PathService here. See Chromium Issue 3113.
 const base::FilePath::CharType kDocRoot[] =
     FILE_PATH_LITERAL("chrome/test/data");
 }
 
 const char kUserAgent[] = "user-agent";
 
+bool GzipUncompress(const char* input, int length, std::string* output) {

[Alexei Svitkine (slow), 2015/07/25 15:50:36]

Ditto here:

https://code.google.com/p/chromium/codesearch#chromium/src/components/metrics...

[Gang Wu, 2015/07/27 22:35:06]

same as previous one.

+  z_stream stream = {0};
+
+  stream.next_in = reinterpret_cast<uint8*>(const_cast<char*>(input));
+  stream.avail_in = length;
+  stream.next_out = reinterpret_cast<uint8*>(&(*output)[0]);
+  stream.avail_out = output->size();
+
+  bool success = false;
+  while (stream.avail_in > 0 && stream.avail_out > 0) {
+    // 16 is added to read in gzip format.
+    int result = inflateInit2(&stream, MAX_WBITS + 16);
+    DCHECK_EQ(Z_OK, result);
+
+    result = inflate(&stream, Z_FINISH);
+    success = (result == Z_STREAM_END);
+    if (!success) {
+      DVLOG(2) << "inflate() failed. Result: " << result;
+      break;
+    }
+
+    result = inflateEnd(&stream);
+    DCHECK(result == Z_OK);
+  }
+
+  if (stream.avail_in == 0) {
+    success = true;
+    output->resize(output->size() - stream.avail_out);
+  }
+  return success;
+}
+
 class SyncHttpBridgeTest : public testing::Test {
  public:
   SyncHttpBridgeTest()
       : test_server_(net::SpawnedTestServer::TYPE_HTTP,
                      net::SpawnedTestServer::kLocalhost,
                      base::FilePath(kDocRoot)),
         fake_default_request_context_getter_(NULL),
         bridge_for_race_test_(NULL),
         io_thread_("IO thread") {
   }
@@ skipping 102 matching lines @@
  private:
   ~ShuntedHttpBridge() override {}
 
   void CallOnURLFetchComplete() {
     ASSERT_TRUE(base::MessageLoop::current() == test_->GetIOThreadLoop());
     // We return no cookies and a dummy content response.
     net::ResponseCookies cookies;
 
     std::string response_content = "success!";
     net::TestURLFetcher fetcher(0, GURL("http://www.google.com"), NULL);
+    scoped_refptr<net::HttpResponseHeaders> response_headers(
+        new net::HttpResponseHeaders(""));
     fetcher.set_response_code(200);
     fetcher.set_cookies(cookies);
     fetcher.SetResponseString(response_content);
+    fetcher.set_response_headers(response_headers);
     OnURLFetchComplete(&fetcher);
   }
   SyncHttpBridgeTest* test_;
   bool never_finishes_;
 };
 
 void SyncHttpBridgeTest::RunSyncThreadBridgeUseTest(
     base::WaitableEvent* signal_when_created,
     base::WaitableEvent* signal_when_released) {
   scoped_refptr<net::URLRequestContextGetter> ctx_getter(
@@ skipping 63 matching lines @@
   bool success = http_bridge->MakeSynchronousPost(&os_error, &response_code);
   EXPECT_TRUE(success);
   EXPECT_EQ(200, response_code);
   EXPECT_EQ(0, os_error);
 
   EXPECT_EQ(payload.length() + 1,
             static_cast<size_t>(http_bridge->GetResponseContentLength()));
   EXPECT_EQ(payload, std::string(http_bridge->GetResponseContent()));
 }
 
+// Full round-trip test of the HttpBridge with compress data, using default
+// UA string and no request cookies.
+TEST_F(SyncHttpBridgeTest, TestMakeSynchronousPostLiveWithCompressedPayload) {
+  ASSERT_TRUE(test_server_.Start());
+
+  scoped_refptr<HttpBridge> http_bridge(BuildBridge());
+
+  std::string payload = "this should be echoed back";
+  GURL echo = test_server_.GetURL("echo");
+  http_bridge->SetURL(echo.spec().c_str(), echo.IntPort());
+  http_bridge->SetPostPayload("application/x-www-form-urlencoded",
+                              payload.length() + 1, payload.c_str());
+  int os_error = 0;
+  int response_code = 0;
+  base::FieldTrialList field_trial_list(new base::MockEntropyProvider());
+  base::FieldTrialList::CreateFieldTrial("SyncHttpContentCompression",
+                                         "Enabled");
+  bool success = http_bridge->MakeSynchronousPost(&os_error, &response_code);
+  EXPECT_TRUE(success);
+  EXPECT_EQ(200, response_code);
+  EXPECT_EQ(0, os_error);
+
+  EXPECT_NE(payload.length() + 1,
+            static_cast<size_t>(http_bridge->GetResponseContentLength()));
+  std::string uncompressed_payload(payload.size() * 10, ' ');
+  GzipUncompress(http_bridge->GetResponseContent(),
+                 http_bridge->GetResponseContentLength(),
+                 &uncompressed_payload);
+  EXPECT_EQ(payload.length() + 1, uncompressed_payload.size());
+  EXPECT_EQ(payload + '\0', uncompressed_payload);
+}
+
+// Full round-trip test of the HttpBridge with compression.
+TEST_F(SyncHttpBridgeTest,
+       TestMakeSynchronousPostLiveComprehensiveWithCompression) {
+  ASSERT_TRUE(test_server_.Start());
+
+  scoped_refptr<HttpBridge> http_bridge(BuildBridge());
+
+  GURL echo_header = test_server_.GetURL("echoall");
+  http_bridge->SetURL(echo_header.spec().c_str(), echo_header.IntPort());
+
+  std::string test_payload = "###TEST PAYLOAD###";
+  http_bridge->SetPostPayload("text/html", test_payload.length() + 1,
+                              test_payload.c_str());
+
+  int os_error = 0;
+  int response_code = 0;
+  base::FieldTrialList field_trial_list(new base::MockEntropyProvider());
+  base::FieldTrialList::CreateFieldTrial("SyncHttpContentCompression",
+                                         "Enabled");
+  bool success = http_bridge->MakeSynchronousPost(&os_error, &response_code);
+  EXPECT_TRUE(success);
+  EXPECT_EQ(200, response_code);
+  EXPECT_EQ(0, os_error);
+
+  std::string response(http_bridge->GetResponseContent(),
+                       http_bridge->GetResponseContentLength());
+  EXPECT_NE(std::string::npos, response.find("Content-Encoding: gzip"));
+  EXPECT_NE(std::string::npos, response.find("Accept-Encoding: gzip, deflate"));
+  EXPECT_NE(std::string::npos,
+            response.find(base::StringPrintf(
+                "%s: %s", net::HttpRequestHeaders::kUserAgent, kUserAgent)));
+}
+
 // Full round-trip test of the HttpBridge.
 TEST_F(SyncHttpBridgeTest, TestMakeSynchronousPostLiveComprehensive) {
   ASSERT_TRUE(test_server_.Start());
 
   scoped_refptr<HttpBridge> http_bridge(BuildBridge());
 
   GURL echo_header = test_server_.GetURL("echoall");
   http_bridge->SetURL(echo_header.spec().c_str(), echo_header.IntPort());
 
   std::string test_payload = "###TEST PAYLOAD###";
   http_bridge->SetPostPayload("text/html", test_payload.length() + 1,
                               test_payload.c_str());
 
   int os_error = 0;
   int response_code = 0;
   bool success = http_bridge->MakeSynchronousPost(&os_error, &response_code);
   EXPECT_TRUE(success);
   EXPECT_EQ(200, response_code);
   EXPECT_EQ(0, os_error);
 
   std::string response(http_bridge->GetResponseContent(),
                        http_bridge->GetResponseContentLength());
   EXPECT_EQ(std::string::npos, response.find("Cookie:"));
+  EXPECT_NE(std::string::npos, response.find("Accept-Encoding: deflate"));
   EXPECT_NE(std::string::npos,
             response.find(base::StringPrintf("%s: %s",
                           net::HttpRequestHeaders::kUserAgent, kUserAgent)));
   EXPECT_NE(std::string::npos, response.find(test_payload.c_str()));
 }
 
 TEST_F(SyncHttpBridgeTest, TestExtraRequestHeaders) {
   ASSERT_TRUE(test_server_.Start());
 
   scoped_refptr<HttpBridge> http_bridge(BuildBridge());
@@ skipping 244 matching lines @@
 
   // Sync thread: Finally run the posted task, only to find that our
   // HttpBridgeFactory has been neutered.  Should not crash.
   factory->Init("TestUserAgent");
 
   // At this point, attempting to use the factory would trigger a crash.  Both
   // this test and the real world code should make sure this never happens.
 };
 
 }  // namespace syncer