[Sync] Add tests for compression from client to server

components/sync/engine/net/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 "components/sync/engine/net/http_bridge.h"
 
 #include <stddef.h>
 
 #include "base/bit_cast.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
+#include "base/test/scoped_feature_list.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "components/sync/base/cancelation_signal.h"
 #include "net/http/http_response_headers.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/zlib/google/compression_utils.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");
 
 }  // namespace
@@ skipping 210 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 compressed data, check if the
+// data is correctly compressed.
+TEST_F(MAYBE_SyncHttpBridgeTest, CompressedRequestPayloadCheck) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeature(kSyncClientToServerCompression);
+
+  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(), 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);
+
+  EXPECT_NE(payload.length() + 1,
+            static_cast<size_t>(http_bridge->GetResponseContentLength()));
+  std::string compressed_payload(http_bridge->GetResponseContent(),
+                                 http_bridge->GetResponseContentLength());
+  std::string uncompressed_payload;
+  compression::GzipUncompress(compressed_payload, &uncompressed_payload);
+  EXPECT_EQ(payload, uncompressed_payload);
+}
+
 // Full round-trip test of the HttpBridge with compression, check if header
 // fields("Content-Encoding" ,"Accept-Encoding" and user agent) are set
 // correctly.
 TEST_F(MAYBE_SyncHttpBridgeTest, CompressedRequestHeaderCheck) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeature(kSyncClientToServerCompression);
+
   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_NE(std::string::npos, response.find("Content-Encoding: gzip"));
   EXPECT_NE(std::string::npos,
             response.find(base::StringPrintf(
                 "%s: %s", net::HttpRequestHeaders::kAcceptEncoding,
                 "gzip, deflate")));
   EXPECT_NE(std::string::npos,
             response.find(base::StringPrintf(
                 "%s: %s", net::HttpRequestHeaders::kUserAgent, kUserAgent)));
 }
 
 // Full round-trip test of the HttpBridge.
@@ skipping 284 matching lines @@
 
   // Sync thread: Finally run the posted task, only to find that our
   // HttpBridgeFactory has been neutered.  Should not crash.
   factory->Init("TestUserAgent", BindToTrackerCallback());
 
   // 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