Extract testing utilities from gdata_wapi_operations_unittest to test_util.

chrome/browser/google_apis/test_util.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 "chrome/browser/google_apis/test_util.h"
 
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
+#include "chrome/browser/google_apis/test_server/http_request.h"
 #include "chrome/browser/google_apis/test_server/http_response.h"
-#include "chrome/browser/google_apis/test_server/http_server.h"
 #include "content/public/browser/browser_thread.h"
 #include "googleurl/src/gurl.h"
 
 namespace google_apis {
 namespace test_util {
 
 // This class is used to monitor if any task is posted to a message loop.
 class TaskObserver : public MessageLoop::TaskObserver {
  public:
   TaskObserver() : posted_(false) {}
   virtual ~TaskObserver() {}
 
   // MessageLoop::TaskObserver overrides.
   virtual void WillProcessTask(base::TimeTicks time_posted) {}
   virtual void DidProcessTask(base::TimeTicks time_posted) {
     posted_ = true;
   }
 
   // Returns true if any task was posted.
   bool posted() const { return posted_; }
 
  private:
   bool posted_;
   DISALLOW_COPY_AND_ASSIGN(TaskObserver);
 };
 
+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;
+}
+
 FilePath GetTestFilePath(const std::string& relative_path) {
   FilePath path;
   if (!PathService::Get(base::DIR_SOURCE_ROOT, &path))
     return FilePath();
   path = path.AppendASCII("chrome")
              .AppendASCII("test")
              .AppendASCII("data")
              .AppendASCII("chromeos")
              .Append(FilePath::FromUTF8Unsafe(relative_path));
   return path;
@@ skipping 120 matching lines @@
   http_response->set_content(content);
   http_response->set_content_type(content_type);
   return http_response.Pass();
 }
 
 void DoNothingForReAuthenticateCallback(
     AuthenticatedOperationInterface* /* operation */) {
   NOTREACHED();
 }
 
+scoped_ptr<test_server::HttpResponse> HandleDownloadRequest(
+    const GURL& base_url,
+    test_server::HttpRequest* out_request,
+    const test_server::HttpRequest& request) {
+  *out_request = request;
+
+  GURL absolute_url = base_url.Resolve(request.relative_url);
+  std::string remaining_path;
+  if (!RemovePrefix(absolute_url.path(), "/files/", &remaining_path))
+    return scoped_ptr<test_server::HttpResponse>();
+  return CreateHttpResponseFromFile(GetTestFilePath(remaining_path));
+}
+
 bool VerifyJsonData(const FilePath& expected_json_file_path,
                     const base::Value* json_data) {
   if (!json_data) {
     LOG(ERROR) << "json_data is NULL";
     return false;
   }
 
   std::string expected_content;
   if (!file_util::ReadFileToString(
           expected_json_file_path, &expected_content)) {
     LOG(ERROR) << "Failed to read file: " << expected_json_file_path.value();
     return false;
   }
 
   scoped_ptr<base::Value> expected_json_data(
       base::JSONReader::Read(expected_content));
   if (!base::Value::Equals(expected_json_data.get(), json_data)) {
     LOG(ERROR)
         << "The value of json_data is different from the file's content.";
     return false;
   }
 
   return true;
 }
 
 }  // namespace test_util
 }  // namespace google_apis