Rename the embedded test server to EmbeddedTestServer in net::test_server namespace.

chrome/browser/google_apis/gdata_wapi_operations_unittest.cc

 // Copyright (c) 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 <algorithm>
 #include <map>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop_proxy.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/google_apis/gdata_wapi_operations.h"
 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
 #include "chrome/browser/google_apis/gdata_wapi_url_generator.h"
 #include "chrome/browser/google_apis/operation_registry.h"
 #include "chrome/browser/google_apis/task_util.h"
 #include "chrome/browser/google_apis/test_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "net/base/escape.h"
+#include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
-#include "net/test/embedded_test_server/http_server.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace google_apis {
 
 namespace {
 
 const char kTestGDataAuthToken[] = "testtoken";
 const char kTestUserAgent[] = "test-user-agent";
 const char kTestETag[] = "test_etag";
@@ skipping 42 matching lines @@
     content_length_ = 0;
   }
 
   virtual void TearDown() OVERRIDE {
     EXPECT_TRUE(test_server_.ShutdownAndWaitUntilComplete());
     request_context_getter_ = NULL;
   }
 
  protected:
   // Handles a request for fetching a resource feed.
-  scoped_ptr<test_server::HttpResponse> HandleResourceFeedRequest(
-      const test_server::HttpRequest& request) {
+  scoped_ptr<net::test_server::HttpResponse> HandleResourceFeedRequest(
+      const net::test_server::HttpRequest& request) {
     http_request_ = request;
 
     const GURL absolute_url = test_server_.GetURL(request.relative_url);
     std::string remaining_path;
     if (absolute_url.path() == "/feeds/default/private/full" &&
-        request.method == test_server::METHOD_POST) {
+        request.method == net::test_server::METHOD_POST) {
       // This is a request for copying a document.
       // TODO(satorux): we should generate valid JSON data for the newly
       // copied document but for now, just return "file_entry.json"
       return test_util::CreateHttpResponseFromFile(
           test_util::GetTestFilePath("chromeos/gdata/file_entry.json"));
     }
 
     if (!test_util::RemovePrefix(absolute_url.path(),
                                  "/feeds/default/private/full",
                                  &remaining_path)) {
-      return scoped_ptr<test_server::HttpResponse>();
+      return scoped_ptr<net::test_server::HttpResponse>();
     }
 
     if (remaining_path.empty()) {
       // Process the default feed.
       return test_util::CreateHttpResponseFromFile(
           test_util::GetTestFilePath("chromeos/gdata/root_feed.json"));
     } else {
       // Process a feed for a single resource ID.
       const std::string resource_id = net::UnescapeURLComponent(
           remaining_path.substr(1), net::UnescapeRule::URL_SPECIAL_CHARS);
       if (resource_id == "file:2_file_resource_id") {
         return test_util::CreateHttpResponseFromFile(
             test_util::GetTestFilePath("chromeos/gdata/file_entry.json"));
       } else if (resource_id == "folder:root/contents" &&
-                 request.method == test_server::METHOD_POST) {
+                 request.method == net::test_server::METHOD_POST) {
         // This is a request for creating a directory in the root directory.
         // TODO(satorux): we should generate valid JSON data for the newly
         // created directory but for now, just return "directory_entry.json"
         return test_util::CreateHttpResponseFromFile(
             test_util::GetTestFilePath("chromeos/gdata/directory_entry.json"));
       } else if (resource_id ==
                  "folder:root/contents/file:2_file_resource_id" &&
-                 request.method == test_server::METHOD_DELETE) {
+                 request.method == net::test_server::METHOD_DELETE) {
         // This is a request for deleting a file from the root directory.
         // TODO(satorux): Investigate what's returned from the server, and
         // copy it. For now, just return a random file, as the contents don't
         // matter.
         return test_util::CreateHttpResponseFromFile(
             test_util::GetTestFilePath("chromeos/gdata/testfile.txt"));
       } else if (resource_id == "invalid_resource_id") {
         // Check if this is an authorization request for an app.
         // This emulates to return invalid formatted result from the server.
-        if (request.method == test_server::METHOD_PUT &&
+        if (request.method == net::test_server::METHOD_PUT &&
             request.content.find("<docs:authorizedApp>") != std::string::npos) {
           return test_util::CreateHttpResponseFromFile(
               test_util::GetTestFilePath("chromeos/gdata/testfile.txt"));
         }
       }
     }
 
-    return scoped_ptr<test_server::HttpResponse>();
+    return scoped_ptr<net::test_server::HttpResponse>();
   }
 
   // Handles a request for fetching a metadata feed.
-  scoped_ptr<test_server::HttpResponse> HandleMetadataRequest(
-      const test_server::HttpRequest& request) {
+  scoped_ptr<net::test_server::HttpResponse> HandleMetadataRequest(
+      const net::test_server::HttpRequest& request) {
     http_request_ = request;
 
     const GURL absolute_url = test_server_.GetURL(request.relative_url);
     if (absolute_url.path() != "/feeds/metadata/default")
-      return scoped_ptr<test_server::HttpResponse>();
+      return scoped_ptr<net::test_server::HttpResponse>();
 
-    scoped_ptr<test_server::HttpResponse> result(
+    scoped_ptr<net::test_server::HttpResponse> result(
         test_util::CreateHttpResponseFromFile(
             test_util::GetTestFilePath(
                 "chromeos/gdata/account_metadata.json")));
     if (absolute_url.query().find("include-installed-apps=true") ==
         string::npos) {
       // Exclude the list of installed apps.
       scoped_ptr<base::Value> parsed_content(
           base::JSONReader::Read(result->content(), base::JSON_PARSE_RFC));
       CHECK(parsed_content);
 
       // Remove the install apps node.
       base::DictionaryValue* dictionary_value;
       CHECK(parsed_content->GetAsDictionary(&dictionary_value));
       dictionary_value->Remove("entry.docs$installedApp", NULL);
 
       // Write back it as the content of the result.
       std::string content;
       base::JSONWriter::Write(parsed_content.get(), &content);
       result->set_content(content);
     }
 
     return result.Pass();
   }
 
   // Handles a request for creating a session for uploading.
-  scoped_ptr<test_server::HttpResponse> HandleCreateSessionRequest(
-      const test_server::HttpRequest& request) {
+  scoped_ptr<net::test_server::HttpResponse> HandleCreateSessionRequest(
+      const net::test_server::HttpRequest& request) {
     http_request_ = request;
 
     const GURL absolute_url = test_server_.GetURL(request.relative_url);
     if (StartsWithASCII(absolute_url.path(),
                         "/feeds/upload/create-session/default/private/full",
                         true)) {  // case sensitive
       // This is an initiating upload URL.
-      scoped_ptr<test_server::HttpResponse> http_response(
-          new test_server::HttpResponse);
+      scoped_ptr<net::test_server::HttpResponse> http_response(
+          new net::test_server::HttpResponse);
 
       // Check an ETag.
       std::map<std::string, std::string>::const_iterator found =
           request.headers.find("If-Match");
       if (found != request.headers.end() &&
           found->second != "*" &&
           found->second != kTestETag) {
-        http_response->set_code(test_server::PRECONDITION);
+        http_response->set_code(net::test_server::PRECONDITION);
         return http_response.Pass();
       }
 
       // Check if the X-Upload-Content-Length is present. If yes, store the
       // length of the file.
       found = request.headers.find("X-Upload-Content-Length");
       if (found == request.headers.end() ||
           !base::StringToInt64(found->second, &content_length_)) {
-        return scoped_ptr<test_server::HttpResponse>();
+        return scoped_ptr<net::test_server::HttpResponse>();
       }
       received_bytes_ = 0;
 
-      http_response->set_code(test_server::SUCCESS);
+      http_response->set_code(net::test_server::SUCCESS);
       GURL upload_url;
       // POST is used for a new file, and PUT is used for an existing file.
-      if (request.method == test_server::METHOD_POST) {
+      if (request.method == net::test_server::METHOD_POST) {
         upload_url = test_server_.GetURL("/upload_new_file");
-      } else if (request.method == test_server::METHOD_PUT) {
+      } else if (request.method == net::test_server::METHOD_PUT) {
         upload_url = test_server_.GetURL("/upload_existing_file");
       } else {
-        return scoped_ptr<test_server::HttpResponse>();
+        return scoped_ptr<net::test_server::HttpResponse>();
       }
       http_response->AddCustomHeader("Location", upload_url.spec());
       return http_response.Pass();
     }
 
-    return scoped_ptr<test_server::HttpResponse>();
+    return scoped_ptr<net::test_server::HttpResponse>();
   }
 
   // Handles a request for uploading content.
-  scoped_ptr<test_server::HttpResponse> HandleUploadRequest(
-      const test_server::HttpRequest& request) {
+  scoped_ptr<net::test_server::HttpResponse> HandleUploadRequest(
+      const net::test_server::HttpRequest& request) {
     http_request_ = request;
 
     const GURL absolute_url = test_server_.GetURL(request.relative_url);
     if (absolute_url.path() != "/upload_new_file" &&
         absolute_url.path() != "/upload_existing_file") {
-      return scoped_ptr<test_server::HttpResponse>();
+      return scoped_ptr<net::test_server::HttpResponse>();
     }
 
     // TODO(satorux): We should create a correct JSON data for the uploaded
     // file, but for now, just return file_entry.json.
-    scoped_ptr<test_server::HttpResponse> response =
+    scoped_ptr<net::test_server::HttpResponse> response =
         test_util::CreateHttpResponseFromFile(
             test_util::GetTestFilePath("chromeos/gdata/file_entry.json"));
     // response.code() is set to SUCCESS. Change it to CREATED if it's a new
     // file.
     if (absolute_url.path() == "/upload_new_file")
-      response->set_code(test_server::CREATED);
+      response->set_code(net::test_server::CREATED);
 
     // Check if the Content-Range header is present. This must be present if
     // the request body is not empty.
     if (!request.content.empty()) {
       std::map<std::string, std::string>::const_iterator iter =
           request.headers.find("Content-Range");
       if (iter == request.headers.end())
-        return scoped_ptr<test_server::HttpResponse>();
+        return scoped_ptr<net::test_server::HttpResponse>();
       int64 length = 0;
       int64 start_position = 0;
       int64 end_position = 0;
       if (!test_util::ParseContentRangeHeader(iter->second,
                                               &start_position,
                                               &end_position,
                                               &length)) {
-        return scoped_ptr<test_server::HttpResponse>();
+        return scoped_ptr<net::test_server::HttpResponse>();
       }
       EXPECT_EQ(start_position, received_bytes_);
       EXPECT_EQ(length, content_length_);
       // end_position is inclusive, but so +1 to change the range to byte size.
       received_bytes_ = end_position + 1;
     }
 
     // Add Range header to the response, based on the values of
     // Content-Range header in the request.
     // The header is annotated only when at least one byte is received.
     if (received_bytes_ > 0) {
       response->AddCustomHeader(
           "Range",
           "bytes=0-" + base::Int64ToString(received_bytes_ - 1));
     }
 
     // Change the code to RESUME_INCOMPLETE if upload is not complete.
     if (received_bytes_ < content_length_)
-      response->set_code(test_server::RESUME_INCOMPLETE);
+      response->set_code(net::test_server::RESUME_INCOMPLETE);
 
     return response.Pass();
   }
 
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   content::TestBrowserThread io_thread_;
-  test_server::HttpServer test_server_;
+  net::test_server::EmbeddedTestServer test_server_;
   scoped_ptr<TestingProfile> profile_;
   OperationRegistry operation_registry_;
   scoped_ptr<GDataWapiUrlGenerator> url_generator_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
 
   // These fields are used to keep the current upload state during a
   // test case. These values are updated by the request from
   // ResumeUploadOperation, and used to construct the response for
   // both ResumeUploadOperation and GetUploadStatusOperation, to emulate
   // the WAPI server.
   int64 received_bytes_;
   int64 content_length_;
 
   // The incoming HTTP request is saved so tests can verify the request
   // parameters like HTTP method (ex. some operations should use DELETE
   // instead of GET).
-  test_server::HttpRequest http_request_;
+  net::test_server::HttpRequest http_request_;
 };
 
 }  // namespace
 
 TEST_F(GDataWapiOperationsTest, GetResourceListOperation_DefaultFeed) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceList> result_data;
 
   GetResourceListOperation* operation = new GetResourceListOperation(
       &operation_registry_,
       request_context_getter_.get(),
       *url_generator_,
       GURL(),         // Pass an empty URL to use the default feed
       0,              // start changestamp
       std::string(),  // search string
       std::string(),  // directory resource ID
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)));
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
-  EXPECT_EQ(test_server::METHOD_GET, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full?v=3&alt=json&showroot=true&"
             "showfolders=true&include-shared=true&max-results=500",
             http_request_.relative_url);
 
   // Sanity check of the result.
   scoped_ptr<ResourceList> expected(
       ResourceList::ExtractAndParse(
           *test_util::LoadJSONFile("chromeos/gdata/root_feed.json")));
   ASSERT_TRUE(result_data);
   EXPECT_EQ(expected->title(), result_data->title());
@@ skipping 12 matching lines @@
       std::string(),  // search string
       std::string(),  // directory resource ID
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)));
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
-  EXPECT_EQ(test_server::METHOD_GET, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/files/chromeos/gdata/root_feed.json?v=3&alt=json&showroot=true&"
             "showfolders=true&include-shared=true&max-results=500",
             http_request_.relative_url);
 
   scoped_ptr<ResourceList> expected(
       ResourceList::ExtractAndParse(
           *test_util::LoadJSONFile("chromeos/gdata/root_feed.json")));
   ASSERT_TRUE(result_data);
   EXPECT_EQ(expected->title(), result_data->title());
 }
@@ skipping 13 matching lines @@
       std::string(),  // search string
       std::string(),  // directory resource ID
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)));
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(GDATA_PARSE_ERROR, result_code);
-  EXPECT_EQ(test_server::METHOD_GET, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/files/chromeos/gdata/testfile.txt?v=3&alt=json&showroot=true&"
             "showfolders=true&include-shared=true&max-results=500",
             http_request_.relative_url);
   EXPECT_FALSE(result_data);
 }
 
 TEST_F(GDataWapiOperationsTest, SearchByTitleOperation) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceList> result_data;
 
   SearchByTitleOperation* operation = new SearchByTitleOperation(
       &operation_registry_,
       request_context_getter_.get(),
       *url_generator_,
       "search-title",
       std::string(),  // directory resource id
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)));
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
-  EXPECT_EQ(test_server::METHOD_GET, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full?v=3&alt=json&showroot=true&"
             "showfolders=true&include-shared=true&max-results=500"
             "&title=search-title&title-exact=true",
             http_request_.relative_url);
   EXPECT_TRUE(result_data);
 }
 
 TEST_F(GDataWapiOperationsTest, GetResourceEntryOperation_ValidResourceId) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result_data;
 
   GetResourceEntryOperation* operation = new GetResourceEntryOperation(
       &operation_registry_,
       request_context_getter_.get(),
       *url_generator_,
       "file:2_file_resource_id",  // resource ID
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)));
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
-  EXPECT_EQ(test_server::METHOD_GET, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full/file%3A2_file_resource_id"
             "?v=3&alt=json&showroot=true",
             http_request_.relative_url);
   EXPECT_TRUE(test_util::VerifyJsonData(
       test_util::GetTestFilePath("chromeos/gdata/file_entry.json"),
       result_data.get()));
 }
 
 TEST_F(GDataWapiOperationsTest, GetResourceEntryOperation_InvalidResourceId) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result_data;
 
   GetResourceEntryOperation* operation = new GetResourceEntryOperation(
       &operation_registry_,
       request_context_getter_.get(),
       *url_generator_,
       "<invalid>",  // resource ID
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)));
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_NOT_FOUND, result_code);
-  EXPECT_EQ(test_server::METHOD_GET, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full/%3Cinvalid%3E?v=3&alt=json"
             "&showroot=true",
             http_request_.relative_url);
   ASSERT_FALSE(result_data);
 }
 
 TEST_F(GDataWapiOperationsTest, GetAccountMetadataOperation) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<AccountMetadata> result_data;
 
   GetAccountMetadataOperation* operation = new GetAccountMetadataOperation(
       &operation_registry_,
       request_context_getter_.get(),
       *url_generator_,
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)),
       true);  // Include installed apps.
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
-  EXPECT_EQ(test_server::METHOD_GET, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/feeds/metadata/default?v=3&alt=json&showroot=true"
             "&include-installed-apps=true",
             http_request_.relative_url);
 
   scoped_ptr<AccountMetadata> expected(
       AccountMetadata::CreateFrom(
           *test_util::LoadJSONFile("chromeos/gdata/account_metadata.json")));
 
   ASSERT_TRUE(result_data.get());
   EXPECT_EQ(expected->largest_changestamp(),
@@ skipping 19 matching lines @@
       *url_generator_,
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)),
       false);  // Exclude installed apps.
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
-  EXPECT_EQ(test_server::METHOD_GET, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/feeds/metadata/default?v=3&alt=json&showroot=true",
             http_request_.relative_url);
 
   scoped_ptr<AccountMetadata> expected(
       AccountMetadata::CreateFrom(
           *test_util::LoadJSONFile("chromeos/gdata/account_metadata.json")));
 
   ASSERT_TRUE(result_data.get());
   EXPECT_EQ(expected->largest_changestamp(),
             result_data->largest_changestamp());
@@ skipping 16 matching lines @@
       CreateComposedCallback(base::Bind(&test_util::RunAndQuit),
                              test_util::CreateCopyResultCallback(&result_code)),
       "file:2_file_resource_id",
       std::string());
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
-  EXPECT_EQ(test_server::METHOD_DELETE, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_DELETE, http_request_.method);
   EXPECT_EQ(
       "/feeds/default/private/full/file%3A2_file_resource_id?v=3&alt=json"
       "&showroot=true",
       http_request_.relative_url);
   EXPECT_EQ("*", http_request_.headers["If-Match"]);
 }
 
 TEST_F(GDataWapiOperationsTest, DeleteResourceOperationWithETag) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
 
   DeleteResourceOperation* operation = new DeleteResourceOperation(
       &operation_registry_,
       request_context_getter_.get(),
       *url_generator_,
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code)),
       "file:2_file_resource_id",
       "etag");
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
-  EXPECT_EQ(test_server::METHOD_DELETE, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_DELETE, http_request_.method);
   EXPECT_EQ(
       "/feeds/default/private/full/file%3A2_file_resource_id?v=3&alt=json"
       "&showroot=true",
       http_request_.relative_url);
   EXPECT_EQ("etag", http_request_.headers["If-Match"]);
 }
 
 TEST_F(GDataWapiOperationsTest, CreateDirectoryOperation) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result_data;
 
   // Create "new directory" in the root directory.
   CreateDirectoryOperation* operation = new CreateDirectoryOperation(
       &operation_registry_,
       request_context_getter_.get(),
       *url_generator_,
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)),
       "folder:root",
       "new directory");
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
-  EXPECT_EQ(test_server::METHOD_POST, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full/folder%3Aroot/contents?v=3&alt=json"
             "&showroot=true",
             http_request_.relative_url);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\">\n"
             " <category scheme=\"http://schemas.google.com/g/2005#kind\" "
             "term=\"http://schemas.google.com/docs/2007#folder\"/>\n"
@@ skipping 15 matching lines @@
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)),
       "document:5_document_resource_id",  // source resource ID
       "New Document");
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
-  EXPECT_EQ(test_server::METHOD_POST, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full?v=3&alt=json&showroot=true",
             http_request_.relative_url);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\">\n"
             " <id>document:5_document_resource_id</id>\n"
             " <title>New Document</title>\n"
             "</entry>\n",
@@ skipping 12 matching lines @@
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code)),
       "file:2_file_resource_id",
       "New File");
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
-  EXPECT_EQ(test_server::METHOD_PUT, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   EXPECT_EQ(
       "/feeds/default/private/full/file%3A2_file_resource_id?v=3&alt=json"
       "&showroot=true",
       http_request_.relative_url);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
   EXPECT_EQ("*", http_request_.headers["If-Match"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\">\n"
@@ skipping 15 matching lines @@
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)),
       "file:2_file_resource_id",
       "APP_ID");
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
-  EXPECT_EQ(test_server::METHOD_PUT, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full/file%3A2_file_resource_id"
             "?v=3&alt=json&showroot=true",
             http_request_.relative_url);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
   EXPECT_EQ("*", http_request_.headers["If-Match"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\" "
             "xmlns:docs=\"http://schemas.google.com/docs/2007\">\n"
@@ skipping 15 matching lines @@
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)),
       "invalid_resource_id",
       "APP_ID");
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(GDATA_PARSE_ERROR, result_code);
-  EXPECT_EQ(test_server::METHOD_PUT, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full/invalid_resource_id"
             "?v=3&alt=json&showroot=true",
             http_request_.relative_url);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
   EXPECT_EQ("*", http_request_.headers["If-Match"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\" "
             "xmlns:docs=\"http://schemas.google.com/docs/2007\">\n"
@@ skipping 15 matching lines @@
               base::Bind(&test_util::RunAndQuit),
               test_util::CreateCopyResultCallback(&result_code)),
           "folder:root",
           "file:2_file_resource_id");
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
-  EXPECT_EQ(test_server::METHOD_POST, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full/folder%3Aroot/contents?v=3&alt=json"
             "&showroot=true",
             http_request_.relative_url);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\">\n"
             " <id>http://127.0.0.1:8040/feeds/default/private/full/"
             "file%3A2_file_resource_id</id>\n"
@@ skipping 15 matching lines @@
               test_util::CreateCopyResultCallback(&result_code)),
           "folder:root",
           "file:2_file_resource_id");
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
                    base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   // DELETE method should be used, without the body content.
-  EXPECT_EQ(test_server::METHOD_DELETE, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_DELETE, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full/folder%3Aroot/contents/"
             "file%3A2_file_resource_id?v=3&alt=json&showroot=true",
             http_request_.relative_url);
   EXPECT_EQ("*", http_request_.headers["If-Match"]);
   EXPECT_FALSE(http_request_.has_content);
 }
 
 // This test exercises InitiateUploadNewFileOperation and
 // ResumeUploadOperation for a scenario of uploading a new file.
 TEST_F(GDataWapiOperationsTest, UploadNewFile) {
@@ skipping 16 matching lines @@
           "folder:id",
           "New file");
 
   initiate_operation->Start(
       kTestGDataAuthToken, kTestUserAgent,
       base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(test_server_.GetURL("/upload_new_file"), upload_url);
-  EXPECT_EQ(test_server::METHOD_POST, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ(
       "/feeds/upload/create-session/default/private/full/folder%3Aid/contents"
       "?convert=false&v=3&alt=json&showroot=true",
       http_request_.relative_url);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kUploadContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
 
@@ skipping 26 matching lines @@
       kUploadContent.size(),  // content_length,
       "text/plain",  // content_type
       buffer);
 
   resume_operation->Start(
       kTestGDataAuthToken, kTestUserAgent,
       base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   // METHOD_PUT should be used to upload data.
-  EXPECT_EQ(test_server::METHOD_PUT, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   // Request should go to the upload URL.
   EXPECT_EQ(upload_url.path(), http_request_.relative_url);
   // Content-Range header should be added.
   EXPECT_EQ("bytes 0-" +
             base::Int64ToString(kUploadContent.size() -1) + "/" +
             base::Int64ToString(kUploadContent.size()),
             http_request_.headers["Content-Range"]);
   // The upload content should be set in the HTTP request.
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ(kUploadContent, http_request_.content);
@@ skipping 34 matching lines @@
           "folder:id",
           "New file");
 
   initiate_operation->Start(
       kTestGDataAuthToken, kTestUserAgent,
       base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(test_server_.GetURL("/upload_new_file"), upload_url);
-  EXPECT_EQ(test_server::METHOD_POST, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ(
       "/feeds/upload/create-session/default/private/full/folder%3Aid/contents"
       "?convert=false&v=3&alt=json&showroot=true",
       http_request_.relative_url);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kUploadContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
 
@@ skipping 23 matching lines @@
             UPLOAD_NEW_FILE,
             base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
             upload_url,
             kUploadContent.size());
     get_upload_status_operation->Start(
         kTestGDataAuthToken, kTestUserAgent,
         base::Bind(&test_util::DoNothingForReAuthenticateCallback));
     MessageLoop::current()->Run();
 
     // METHOD_PUT should be used to upload data.
-    EXPECT_EQ(test_server::METHOD_PUT, http_request_.method);
+    EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
     // Request should go to the upload URL.
     EXPECT_EQ(upload_url.path(), http_request_.relative_url);
     // Content-Range header should be added.
     EXPECT_EQ("bytes */" + base::Int64ToString(kUploadContent.size()),
               http_request_.headers["Content-Range"]);
     EXPECT_TRUE(http_request_.has_content);
     EXPECT_TRUE(http_request_.content.empty());
 
     // Check the response.
     EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
@@ skipping 35 matching lines @@
         kUploadContent.size(),  // content_length,
         "text/plain",  // content_type
         buffer);
 
     resume_operation->Start(
         kTestGDataAuthToken, kTestUserAgent,
         base::Bind(&test_util::DoNothingForReAuthenticateCallback));
     MessageLoop::current()->Run();
 
     // METHOD_PUT should be used to upload data.
-    EXPECT_EQ(test_server::METHOD_PUT, http_request_.method);
+    EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
     // Request should go to the upload URL.
     EXPECT_EQ(upload_url.path(), http_request_.relative_url);
     // Content-Range header should be added.
     EXPECT_EQ("bytes " +
               base::Int64ToString(start_position) + "-" +
               base::Int64ToString(end_position - 1) + "/" +
               base::Int64ToString(kUploadContent.size()),
               http_request_.headers["Content-Range"]);
     // The upload content should be set in the HTTP request.
     EXPECT_TRUE(http_request_.has_content);
@@ skipping 26 matching lines @@
             UPLOAD_NEW_FILE,
             base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
             upload_url,
             kUploadContent.size());
     get_upload_status_operation->Start(
         kTestGDataAuthToken, kTestUserAgent,
         base::Bind(&test_util::DoNothingForReAuthenticateCallback));
     MessageLoop::current()->Run();
 
     // METHOD_PUT should be used to upload data.
-    EXPECT_EQ(test_server::METHOD_PUT, http_request_.method);
+    EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
     // Request should go to the upload URL.
     EXPECT_EQ(upload_url.path(), http_request_.relative_url);
     // Content-Range header should be added.
     EXPECT_EQ("bytes */" + base::Int64ToString(kUploadContent.size()),
               http_request_.headers["Content-Range"]);
     EXPECT_TRUE(http_request_.has_content);
     EXPECT_TRUE(http_request_.content.empty());
 
     // Check the response.
     EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
@@ skipping 30 matching lines @@
           "folder:id",
           "New file");
 
   initiate_operation->Start(
       kTestGDataAuthToken, kTestUserAgent,
       base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(test_server_.GetURL("/upload_new_file"), upload_url);
-  EXPECT_EQ(test_server::METHOD_POST, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ(
       "/feeds/upload/create-session/default/private/full/folder%3Aid/contents"
       "?convert=false&v=3&alt=json&showroot=true",
       http_request_.relative_url);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kUploadContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
 
@@ skipping 26 matching lines @@
       kUploadContent.size(),  // content_length,
       "text/plain",  // content_type
       buffer);
 
   resume_operation->Start(
       kTestGDataAuthToken, kTestUserAgent,
       base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   // METHOD_PUT should be used to upload data.
-  EXPECT_EQ(test_server::METHOD_PUT, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   // Request should go to the upload URL.
   EXPECT_EQ(upload_url.path(), http_request_.relative_url);
   // Content-Range header should not exit if the content is empty.
   // We should not generate the header with an invalid value "bytes 0--1/0".
   EXPECT_EQ(0U, http_request_.headers.count("Content-Range"));
   // The upload content should be set in the HTTP request.
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ(kUploadContent, http_request_.content);
 
   // Check the response.
@@ skipping 26 matching lines @@
           std::string() /* etag */);
 
   initiate_operation->Start(
       kTestGDataAuthToken, kTestUserAgent,
       base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(test_server_.GetURL("/upload_existing_file"), upload_url);
   // For updating an existing file, METHOD_PUT should be used.
-  EXPECT_EQ(test_server::METHOD_PUT, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ("/feeds/upload/create-session/default/private/full/file%3Afoo"
             "?convert=false&v=3&alt=json&showroot=true",
             http_request_.relative_url);
   // Even though the body is empty, the content type should be set to
   // "text/plain".
   EXPECT_EQ("text/plain", http_request_.headers["Content-Type"]);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kUploadContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
@@ skipping 24 matching lines @@
       kUploadContent.size(),  // content_length,
       "text/plain",  // content_type
       buffer);
 
   resume_operation->Start(
       kTestGDataAuthToken, kTestUserAgent,
       base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   // METHOD_PUT should be used to upload data.
-  EXPECT_EQ(test_server::METHOD_PUT, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   // Request should go to the upload URL.
   EXPECT_EQ(upload_url.path(), http_request_.relative_url);
   // Content-Range header should be added.
   EXPECT_EQ("bytes 0-" +
             base::Int64ToString(kUploadContent.size() -1) + "/" +
             base::Int64ToString(kUploadContent.size()),
             http_request_.headers["Content-Range"]);
   // The upload content should be set in the HTTP request.
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ(kUploadContent, http_request_.content);
@@ skipping 28 matching lines @@
           kTestETag);
 
   initiate_operation->Start(
       kTestGDataAuthToken, kTestUserAgent,
       base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(test_server_.GetURL("/upload_existing_file"), upload_url);
   // For updating an existing file, METHOD_PUT should be used.
-  EXPECT_EQ(test_server::METHOD_PUT, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ("/feeds/upload/create-session/default/private/full/file%3Afoo"
             "?convert=false&v=3&alt=json&showroot=true",
             http_request_.relative_url);
   // Even though the body is empty, the content type should be set to
   // "text/plain".
   EXPECT_EQ("text/plain", http_request_.headers["Content-Type"]);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kUploadContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
@@ skipping 24 matching lines @@
       kUploadContent.size(),  // content_length,
       "text/plain",  // content_type
       buffer);
 
   resume_operation->Start(
       kTestGDataAuthToken, kTestUserAgent,
       base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   // METHOD_PUT should be used to upload data.
-  EXPECT_EQ(test_server::METHOD_PUT, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   // Request should go to the upload URL.
   EXPECT_EQ(upload_url.path(), http_request_.relative_url);
   // Content-Range header should be added.
   EXPECT_EQ("bytes 0-" +
             base::Int64ToString(kUploadContent.size() -1) + "/" +
             base::Int64ToString(kUploadContent.size()),
             http_request_.headers["Content-Range"]);
   // The upload content should be set in the HTTP request.
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ(kUploadContent, http_request_.content);
@@ skipping 27 matching lines @@
           "file:foo",
           kWrongETag);
 
   initiate_operation->Start(
       kTestGDataAuthToken, kTestUserAgent,
       base::Bind(&test_util::DoNothingForReAuthenticateCallback));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_PRECONDITION, result_code);
   // For updating an existing file, METHOD_PUT should be used.
-  EXPECT_EQ(test_server::METHOD_PUT, http_request_.method);
+  EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ("/feeds/upload/create-session/default/private/full/file%3Afoo"
             "?convert=false&v=3&alt=json&showroot=true",
             http_request_.relative_url);
   // Even though the body is empty, the content type should be set to
   // "text/plain".
   EXPECT_EQ("text/plain", http_request_.headers["Content-Type"]);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kUploadContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
   // For updating an existing file, an empty body should be attached (PUT
   // requires a body)
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("", http_request_.content);
   EXPECT_EQ(kWrongETag, http_request_.headers["If-Match"]);
 }
 
 }  // namespace google_apis