Extract testing utilities from gdata_wapi_operations_unittest to test_util.

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_path.h"
 #include "base/file_util.h"
@@ skipping 53 matching lines @@
 void CopyResultFromResumeUploadCallbackAndQuit(
     ResumeUploadResponse* out_response,
     scoped_ptr<ResourceEntry>* out_new_entry,
     const ResumeUploadResponse& response,
     scoped_ptr<ResourceEntry> new_entry) {
   *out_response = response;
   *out_new_entry = new_entry.Pass();
   MessageLoop::current()->Quit();
 }
 
-// Removes |prefix| from |input| and stores the result in |output|. Returns
-// true if the prefix is removed.
-bool RemovePrefix(const std::string& input,
-                  const std::string& prefix,
-                  std::string* output) {
-  if (!StartsWithASCII(input, prefix, true /* case sensitive */))
-    return false;
-
-  *output = input.substr(prefix.size());
-  return true;
-}
-
 // Parses a value of Content-Range header, which looks like
 // "bytes <start_position>-<end_position>/<length>".
 // Returns true on success.
 bool ParseContentRangeHeader(const std::string& value,
                              int64* start_position,
                              int64* end_position,
                              int64* length) {
   DCHECK(start_position);
   DCHECK(end_position);
   DCHECK(length);
 
   std::string remaining;
-  if (!RemovePrefix(value, "bytes ", &remaining))
+  if (!test_util::RemovePrefix(value, "bytes ", &remaining))
     return false;
 
   std::vector<std::string> parts;
   base::SplitString(remaining, '/', &parts);
   if (parts.size() != 2U)
     return false;
 
   const std::string range = parts[0];
   if (!base::StringToInt64(parts[1], length))
     return false;
@@ skipping 19 matching lines @@
     file_thread_.Start();
     io_thread_.StartIOThread();
     profile_.reset(new TestingProfile);
 
     request_context_getter_ = new net::TestURLRequestContextGetter(
         content::BrowserThread::GetMessageLoopProxyForThread(
             content::BrowserThread::IO));
 
     ASSERT_TRUE(test_server_.InitializeAndWaitUntilReady());
     test_server_.RegisterRequestHandler(
-        base::Bind(&GDataWapiOperationsTest::HandleDownloadRequest,
-                   base::Unretained(this)));
+        base::Bind(&test_util::HandleDownloadRequest,
+                   test_server_.base_url(),
+                   base::Unretained(&http_request_)));
     test_server_.RegisterRequestHandler(
         base::Bind(&GDataWapiOperationsTest::HandleResourceFeedRequest,
                    base::Unretained(this)));
     test_server_.RegisterRequestHandler(
         base::Bind(&GDataWapiOperationsTest::HandleMetadataFeedRequest,
                    base::Unretained(this)));
     test_server_.RegisterRequestHandler(
         base::Bind(&GDataWapiOperationsTest::HandleCreateSessionRequest,
                    base::Unretained(this)));
     test_server_.RegisterRequestHandler(
         base::Bind(&GDataWapiOperationsTest::HandleUploadRequest,
                    base::Unretained(this)));
 
     url_generator_.reset(new GDataWapiUrlGenerator(
         test_util::GetBaseUrlForTesting(test_server_.port())));
   }
 
   virtual void TearDown() OVERRIDE {
     test_server_.ShutdownAndWaitUntilComplete();
     request_context_getter_ = NULL;
   }
 
  protected:
   // Returns a temporary file path suitable for storing the cache file.
   FilePath GetTestCachedFilePath(const FilePath& file_name) {
     return profile_->GetPath().Append(file_name);
   }
 
-  // Handles a request for downloading a file. Reads a file from the test
-  // directory and returns the content.
-  scoped_ptr<test_server::HttpResponse> HandleDownloadRequest(
-      const test_server::HttpRequest& request) {
-    http_request_ = request;
-
-    const GURL absolute_url = test_server_.GetURL(request.relative_url);
-    std::string remaining_path;
-    if (!RemovePrefix(absolute_url.path(), "/files/", &remaining_path))
-      return scoped_ptr<test_server::HttpResponse>();
-
-    return test_util::CreateHttpResponseFromFile(
-        test_util::GetTestFilePath(remaining_path));
-  }
-
   // Handles a request for fetching a resource feed.
   scoped_ptr<test_server::HttpResponse> HandleResourceFeedRequest(
       const 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) {
       // 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("gdata/file_entry.json"));
     }
 
-    if (!RemovePrefix(absolute_url.path(),
-                      "/feeds/default/private/full/",
-                      &remaining_path)) {
+    if (!test_util::RemovePrefix(absolute_url.path(),
+                                 "/feeds/default/private/full/",
+                                 &remaining_path)) {
       return scoped_ptr<test_server::HttpResponse>();
     }
 
     if (remaining_path == "-/mine") {
       // Process the default feed.
       return test_util::CreateHttpResponseFromFile(
           test_util::GetTestFilePath("gdata/root_feed.json"));
     } else {
       // Process a feed for a single resource ID.
       const std::string resource_id = net::UnescapeURLComponent(
@@ skipping 1196 matching lines @@
   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