Keep only base/extractor.[cc|h].

net/http_client_unittest.cc

Index: net/http_client_unittest.cc
diff --git a/net/http_client_unittest.cc b/net/http_client_unittest.cc
deleted file mode 100644
index 038a4649d28afdf03d5cc37799c172c93302e4c1..0000000000000000000000000000000000000000
--- a/net/http_client_unittest.cc
+++ /dev/null
@@ -1,245 +0,0 @@
-// Copyright 2007-2009 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-// ========================================================================
-
-// Since the net code is linked in as a lib, force the registration code to
-// be a dependency, otherwise the linker is optimizing in out.
-#pragma comment(linker, "/INCLUDE:_kRegisterWinHttp")
-
-#include <vector>
-#include "base/basictypes.h"
-#include "base/scoped_ptr.h"
-#include "omaha/base/omaha_version.h"
-#include "omaha/net/http_client.h"
-#include "omaha/testing/unit_test.h"
-
-namespace omaha {
-
-// Test fixture, perhaps we need it later.
-class HttpClientTest : public testing::Test {
- protected:
-  HttpClientTest() {}
-
-  static void SetUpTestCase() {}
-
-  virtual void SetUp() {
-    http_client_.reset(
-        HttpClient::GetFactory().CreateObject(HttpClient::WINHTTP));
-    ASSERT_TRUE(http_client_.get());
-    ASSERT_SUCCEEDED(http_client_->Initialize());
-  }
-
-  virtual void TearDown() {
-    http_client_.reset();
-  }
-
-  void GetUrl(const TCHAR* url, bool use_proxy);
-
-  scoped_ptr<HttpClient> http_client_;
-};
-
-CString BuildUserAgent() {
-  CString user_agent;
-  user_agent.Format(_T("HttpClientTest version %s"), omaha::GetVersionString());
-  return user_agent;
-}
-
-const TCHAR kTestUrlGet[]       = _T("http://www.google.com/robots.txt");
-const TCHAR kTestSecureUrlGet[] = _T("https://www.google.com/robots.txt");
-
-// If using a proxy is specified, the function does WPAD detection to get the
-// name of the proxy to be used. The request goes direct if the WPAD fails.
-void HttpClientTest::GetUrl(const TCHAR* url, bool use_proxy) {
-  ASSERT_TRUE(url);
-
-  CString server, path;
-  int port = 0;
-  ASSERT_SUCCEEDED(http_client_->CrackUrl(url,
-                                          ICU_DECODE,
-                                          NULL,
-                                          &server,
-                                          &port,
-                                          &path,
-                                          NULL));
-  ASSERT_STREQ(server, _T("www.google.com"));
-  ASSERT_STREQ(path, _T("/robots.txt"));
-
-  HINTERNET session_handle = NULL;
-  ASSERT_SUCCEEDED(http_client_->Open(BuildUserAgent(),
-                                      HttpClient::kAccessTypeNoProxy,
-                                      NULL,
-                                      NULL,
-                                      0,    // Synchronous mode.
-                                      &session_handle));
-  if (use_proxy) {
-    HttpClient::AutoProxyOptions autoproxy_options = {0};
-    autoproxy_options.flags = WINHTTP_AUTOPROXY_AUTO_DETECT;
-    autoproxy_options.auto_detect_flags = WINHTTP_AUTO_DETECT_TYPE_DHCP |
-                                          WINHTTP_AUTO_DETECT_TYPE_DNS_A;
-    autoproxy_options.auto_logon_if_challenged = true;
-    HttpClient::ProxyInfo proxy_info = {0};
-    http_client_->GetProxyForUrl(session_handle,
-                                 url,
-                                 &autoproxy_options,
-                                 &proxy_info);
-    if (proxy_info.proxy && wcslen(proxy_info.proxy)) {
-      proxy_info.access_type = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
-      EXPECT_SUCCEEDED(http_client_->SetOption(session_handle,
-                                               WINHTTP_OPTION_PROXY,
-                                               &proxy_info,
-                                               sizeof(proxy_info)));
-    }
-    ::GlobalFree(const_cast<wchar_t*>(proxy_info.proxy));
-    ::GlobalFree(const_cast<wchar_t*>(proxy_info.proxy_bypass));
-  }
-
-  HINTERNET connection_handle = NULL;
-  ASSERT_SUCCEEDED(http_client_->Connect(session_handle,
-                                         server,
-                                         port,
-                                         &connection_handle));
-  uint32 flags = port == 443 ? WINHTTP_FLAG_SECURE : 0;
-  HINTERNET request_handle = NULL;
-  ASSERT_SUCCEEDED(http_client_->OpenRequest(connection_handle,
-                                             _T("GET"),
-                                             path,
-                                             NULL,     // HTTP 1.1
-                                             NULL,     // Referrer.
-                                             NULL,     // Default accept types.
-                                             flags,
-                                             &request_handle));
-  ASSERT_SUCCEEDED(http_client_->SendRequest(request_handle,
-                                             NULL, 0, NULL, 0, 0, 0));
-  ASSERT_SUCCEEDED(http_client_->ReceiveResponse(request_handle));
-  CString content_type;
-  EXPECT_SUCCEEDED(http_client_->QueryHeadersString(request_handle,
-                                                    WINHTTP_QUERY_CONTENT_TYPE,
-                                                    NULL,
-                                                    &content_type,
-                                                    NULL));
-  EXPECT_STREQ(content_type, _T("text/plain"));
-  CString server_header;
-  EXPECT_SUCCEEDED(http_client_->QueryHeadersString(request_handle,
-                                                    WINHTTP_QUERY_SERVER,
-                                                    NULL,
-                                                    &server_header,
-                                                    NULL));
-  CString response;
-  DWORD size = 0;
-  do {
-    // Use ReadData to determine when a response has been completely read.
-    // Always allocate a buffer for ReadData even though QueryDataAvailable
-    // might return 0 bytes available.
-    ASSERT_SUCCEEDED(http_client_->QueryDataAvailable(request_handle, &size));
-    std::vector<uint8> buf(size + 1);
-    ASSERT_SUCCEEDED(http_client_->ReadData(request_handle,
-                                            &buf.front(),
-                                            buf.size(),
-                                            &size));
-    buf.resize(size);
-    if (size) {
-      response += CString(reinterpret_cast<char*>(&buf.front()), buf.size());
-    }
-  } while (size > 0);
-
-  // Compare a little bit of the body.
-  response.Truncate(10);
-  ASSERT_STREQ(response, _T("User-agent"));
-
-  ASSERT_SUCCEEDED(http_client_->Close(request_handle));
-  ASSERT_SUCCEEDED(http_client_->Close(connection_handle));
-  ASSERT_SUCCEEDED(http_client_->Close(session_handle));
-}
-
-TEST_F(HttpClientTest, Get) {
-  if (IsTestRunByLocalSystem()) {
-    return;
-  }
-
-  GetUrl(kTestUrlGet, false);
-}
-
-TEST_F(HttpClientTest, SecureGet) {
-  if (IsTestRunByLocalSystem()) {
-    return;
-  }
-
-  GetUrl(kTestSecureUrlGet, false);
-}
-
-TEST_F(HttpClientTest, ProxyGet) {
-  GetUrl(kTestUrlGet, true);
-}
-
-TEST_F(HttpClientTest, ProxySecureGet) {
-  GetUrl(kTestSecureUrlGet, true);
-}
-
-TEST_F(HttpClientTest, BuildRequestHeader) {
-  ASSERT_STREQ(HttpClient::BuildRequestHeader(_T("foo"), _T("bar")),
-               _T("foo: bar\r\n"));
-}
-
-TEST_F(HttpClientTest, GetStatusCodeClass) {
-  EXPECT_EQ(HttpClient::GetStatusCodeClass(HTTP_STATUS_CONTINUE),
-            HttpClient::STATUS_CODE_INFORMATIONAL);
-
-  EXPECT_EQ(HttpClient::GetStatusCodeClass(HTTP_STATUS_OK),
-            HttpClient::STATUS_CODE_SUCCESSFUL);
-
-  EXPECT_EQ(HttpClient::GetStatusCodeClass(HTTP_STATUS_PARTIAL_CONTENT),
-            HttpClient::STATUS_CODE_SUCCESSFUL);
-
-  EXPECT_EQ(HttpClient::GetStatusCodeClass(HTTP_STATUS_AMBIGUOUS),
-            HttpClient::STATUS_CODE_REDIRECTION);
-
-  EXPECT_EQ(HttpClient::GetStatusCodeClass(HTTP_STATUS_REDIRECT),
-            HttpClient::STATUS_CODE_REDIRECTION);
-
-  EXPECT_EQ(HttpClient::GetStatusCodeClass(HTTP_STATUS_BAD_REQUEST),
-            HttpClient::STATUS_CODE_CLIENT_ERROR);
-
-  EXPECT_EQ(HttpClient::GetStatusCodeClass(HTTP_STATUS_SERVICE_UNAVAIL),
-            HttpClient::STATUS_CODE_SERVER_ERROR);
-}
-
-TEST_F(HttpClientTest, CrackUrl) {
-  CString scheme, server, path, query;
-  int port = 0;
-  ASSERT_SUCCEEDED(http_client_->CrackUrl(_T("http://host/path?query"),
-                                          0,
-                                          &scheme,
-                                          &server,
-                                          &port,
-                                          &path,
-                                          &query));
-  ASSERT_STREQ(scheme, _T("http"));
-  ASSERT_STREQ(server, _T("host"));
-  ASSERT_EQ(port, INTERNET_DEFAULT_HTTP_PORT);
-  ASSERT_STREQ(path, _T("/path"));
-  ASSERT_STREQ(query, _T("?query"));
-
-  ASSERT_SUCCEEDED(http_client_->CrackUrl(_T("http://host"),
-                                          0,
-                                          NULL,
-                                          NULL,
-                                          NULL,
-                                          &path,
-                                          &query));
-  ASSERT_STREQ(path, _T(""));
-  ASSERT_STREQ(query, _T(""));
-}
-
-}  // namespace omaha
-