SdchManager: remove EnableSdchSupport

ios/crnet/test/crnet_http_tests.mm

 // Copyright 2015 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.
 
 #import <Foundation/Foundation.h>
 
 #import "CrNet.h"
 
+#include "base/logging.h"
 #include "base/mac/scoped_nsobject.h"
+#include "base/strings/sys_string_conversions.h"
 #import "ios/third_party/gcdwebserver/src/GCDWebServer/Core/GCDWebServer.h"
 #include "net/base/mac/url_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gtest_mac.h"
 #include "url/gurl.h"
 
 @interface TestDelegate : NSObject<NSURLSessionDataDelegate,
                                    NSURLSessionDelegate,
                                    NSURLSessionTaskDelegate>
 
@@ skipping 107 matching lines @@
   // root URL for later; tests can use GetURL() to produce a URL referring to a
   // specific resource under the root URL.
   void StartWebServer() {
     [web_server_ startWithPort:8080 bonjourName:nil];
     server_root_ = net::GURLWithNSURL([web_server_ serverURL]);
   }
 
   // Registers a fixed response |text| to be returned to requests for |path|,
   // which is relative to |server_root_|.
   void RegisterPathText(const std::string& path, const std::string& text) {
-    NSString* nspath =
-        [NSString stringWithCString:path.c_str() encoding:NSUTF8StringEncoding];
+    NSString* nspath = base::SysUTF8ToNSString(path);
     NSData* data = [NSData dataWithBytes:text.c_str() length:text.length()];
     [web_server_ addGETHandlerForPath:nspath
                           staticData:data
                          contentType:@"text/plain"
                             cacheAge:30];
   }
 
+  void RegisterPathHandler(const std::string& path,
+                           GCDWebServerProcessBlock handler) {
+    NSString* nspath = base::SysUTF8ToNSString(path);
+    [web_server_ addHandlerForMethod:@"GET"
+                                path:nspath
+                        requestClass:NSClassFromString(@"GCDWebServerRequest")
+                        processBlock:handler];
+  }
+
   // Launches the supplied |task| and blocks until it completes, with a timeout
   // of 1 second.
   void StartDataTaskAndWaitForCompletion(NSURLSessionDataTask* task) {
     [task resume];
     int64_t deadline_ns = 1 * ns_in_second;
     dispatch_semaphore_wait([delegate_ semaphore],
                             dispatch_time(DISPATCH_TIME_NOW, deadline_ns));
   }
 
   // Returns a URL to refer to the resource named |path| served by the test
   // server. If |path| starts with a /, the leading / will be stripped.
   GURL GetURL(const std::string& path) {
     std::string real_path = path[0] == '/' ? path.substr(1) : path;
     return server_root_.Resolve(real_path);
   }
 
+  // Some convenience functions for working with GCDWebServerRequest and
+  // GCDWebServerResponse.
+
+  // Returns true if the value for the request header |header| is not nil and
+  // contains the string |target|.
+  bool HeaderValueContains(GCDWebServerRequest* request,
+                           const std::string& header,
+                           const std::string& target) {
+    NSString* key = base::SysUTF8ToNSString(header);
+    NSString* needle = base::SysUTF8ToNSString(target);
+    NSString* haystack = request.headers[key];
+    if (!haystack)
+      return false;
+    return [haystack rangeOfString:needle].location != NSNotFound;
+  }
+
   base::scoped_nsobject<NSURLSession> session_;
   base::scoped_nsobject<TestDelegate> delegate_;
 
  private:
   base::scoped_nsobject<GCDWebServer> web_server_;
   GURL server_root_;
 };
 
 TEST_F(HttpTest, NSURLConnectionReceivesData) {
   const char kData[] = "foobar";
   const char kPath[] = "/foo";
   RegisterPathText(kPath, kData);
   StartWebServer();
 
   NSURL* url = net::NSURLWithGURL(GetURL(kPath));
   NSURLRequest* req = [NSURLRequest requestWithURL:url];
   NSURLResponse* resp = nil;
+  NSData* received = [NSURLConnection sendSynchronousRequest:req
+                                           returningResponse:&resp
+                                                       error:nullptr];
+  EXPECT_EQ(0, memcmp([received bytes], kData, sizeof(kData)));
+}
+
+TEST_F(HttpTest, NSURLSessionReceivesData) {
+  const char kPath[] = "/foo";
+  const char kData[] = "foobar";
+  RegisterPathText(kPath, kData);
+  StartWebServer();
+
+  NSURL* url = net::NSURLWithGURL(GetURL(kPath));
+  NSURLSessionDataTask* task = [session_ dataTaskWithURL:url];
+  StartDataTaskAndWaitForCompletion(task);
+  EXPECT_EQ(nil, [delegate_ error]);
+  EXPECT_EQ(strlen(kData), [delegate_ receivedBytes]);
+}
+
+TEST_F(HttpTest, SdchDisabledByDefault) {
+  const char kPath[] = "/foo";
+  RegisterPathHandler(kPath,
+      ^GCDWebServerResponse* (GCDWebServerRequest* req) {
+        EXPECT_FALSE(HeaderValueContains(req, "Accept-Encoding", "sdch"));
+        return nil;
+      });
+  StartWebServer();
+  NSURL* url = net::NSURLWithGURL(GetURL(kPath));
+  NSURLRequest* req = [NSURLRequest requestWithURL:url];
+  NSURLResponse* resp = nil;
   NSError* error = nil;
   NSData* received = [NSURLConnection sendSynchronousRequest:req
                                            returningResponse:&resp
                                                        error:&error];
-  EXPECT_EQ(0, memcmp([received bytes], kData, sizeof(kData)));
+  DCHECK(received);
 }
 
-TEST_F(HttpTest, NSURLSessionReceivesData) {
-  const char data[] = "foobar";
-  RegisterPathText("/foo", data);
-  StartWebServer();
-
-  NSURL* url = net::NSURLWithGURL(GetURL("foo"));
-  NSURLSessionDataTask* task = [session_ dataTaskWithURL:url];
-  StartDataTaskAndWaitForCompletion(task);
-  EXPECT_EQ(nil, [delegate_ error]);
-  EXPECT_EQ(strlen(data), [delegate_ receivedBytes]);
-}
+// TODO(ellyjones): There needs to be a test that enabling SDCH works, but
+// because CrNet is static and 'uninstall' only disables it, there is no way to
+// have an individual test enable or disable SDCH.
+// Probably there is a way to get gtest tests to run in a separate process, but
+// I'm not sure what it is.