Add unittest for google_apis::GetAboutOperation.

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"
-#include "base/json/json_reader.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/stringprintf.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/test_server/http_server.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/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";
 
-// Copies the results from GetDataCallback and quit the message loop.
-void CopyResultsFromGetDataCallbackAndQuit(
-    GDataErrorCode* out_result_code,
-    scoped_ptr<base::Value>* out_result_data,
-    GDataErrorCode result_code,
-    scoped_ptr<base::Value> result_data) {
-  *out_result_code = result_code;
-  *out_result_data = result_data.Pass();
-  MessageLoop::current()->Quit();
-}
-
 // Copies the results from DownloadActionCallback and quit the message loop.
 // The contents of the download cache file are copied to a string, and the
 // file is removed.
 void CopyResultsFromDownloadActionCallbackAndQuit(
     GDataErrorCode* out_result_code,
     std::string* contents,
     GDataErrorCode result_code,
     const FilePath& cache_file_path) {
   *out_result_code = result_code;
   file_util::ReadFileToString(cache_file_path, contents);
@@ skipping 24 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();
 }
 
-// Returns true if |json_data| equals to JSON data in |expected_json_file_path|.
-bool VerifyJsonData(const FilePath& expected_json_file_path,
-                    const base::Value* json_data) {
-  std::string expected_contents;
-  if (!file_util::ReadFileToString(expected_json_file_path, &expected_contents))
-    return false;
-
-  scoped_ptr<base::Value> expected_data(
-      base::JSONReader::Read(expected_contents));
-  return base::Value::Equals(expected_data.get(), json_data);
-}
-
 // 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;
@@ skipping 25 matching lines @@
 
   parts.clear();
   base::SplitString(range, '-', &parts);
   if (parts.size() != 2U)
     return false;
 
   return (base::StringToInt64(parts[0], start_position) &&
           base::StringToInt64(parts[1], end_position));
 }
 
-// Does nothing for ReAuthenticateCallback(). This function should not be
-// reached as there won't be any authentication failures in the test.
-void DoNothingForReAuthenticateCallback(
-    AuthenticatedOperationInterface* /* operation */) {
-  NOTREACHED();
-}
-
 class GDataWapiOperationsTest : public testing::Test {
  public:
   GDataWapiOperationsTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         file_thread_(content::BrowserThread::FILE),
         io_thread_(content::BrowserThread::IO) {
   }
 
   virtual void SetUp() OVERRIDE {
     file_thread_.Start();
@@ skipping 244 matching lines @@
 
   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
       "",  // search string
       false,  // shared with me
       "",  // directory resource ID
-      base::Bind(&CopyResultsFromGetDataCallbackAndQuit,
+      base::Bind(&test_util::CopyResultsFromGetDataCallbackAndQuit,
                  &result_code,
                  &result_data));
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/feeds/default/private/full/-/mine?v=3&alt=json&showfolders=true"
             "&max-results=500&include-installed-apps=true",
             http_request_.relative_url);
-  ASSERT_TRUE(result_data);
-  EXPECT_TRUE(VerifyJsonData(
+  EXPECT_TRUE(test_util::VerifyJsonData(
       test_util::GetTestFilePath("gdata/root_feed.json"),
       result_data.get()));
 }
 
 TEST_F(GDataWapiOperationsTest, GetResourceListOperation_ValidFeed) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result_data;
 
   GetResourceListOperation* operation = new GetResourceListOperation(
       &operation_registry_,
       request_context_getter_.get(),
       *url_generator_,
       test_server_.GetURL("/files/gdata/root_feed.json"),
       0,  // start changestamp
       "",  // search string
       false,  // shared with me
       "",  // directory resource ID
-      base::Bind(&CopyResultsFromGetDataCallbackAndQuit,
+      base::Bind(&test_util::CopyResultsFromGetDataCallbackAndQuit,
                  &result_code,
                  &result_data));
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/files/gdata/root_feed.json?v=3&alt=json&showfolders=true"
             "&max-results=500&include-installed-apps=true",
             http_request_.relative_url);
-  ASSERT_TRUE(result_data);
-  EXPECT_TRUE(VerifyJsonData(
+  EXPECT_TRUE(test_util::VerifyJsonData(
       test_util::GetTestFilePath("gdata/root_feed.json"),
       result_data.get()));
 }
 
 TEST_F(GDataWapiOperationsTest, GetResourceListOperation_InvalidFeed) {
   // testfile.txt exists but the response is not JSON, so it should
   // emit a parse error instead.
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result_data;
 
   GetResourceListOperation* operation = new GetResourceListOperation(
       &operation_registry_,
       request_context_getter_.get(),
       *url_generator_,
       test_server_.GetURL("/files/gdata/testfile.txt"),
       0,  // start changestamp
       "",  // search string
       false,  // shared with me
       "",  // directory resource ID
-      base::Bind(&CopyResultsFromGetDataCallbackAndQuit,
+      base::Bind(&test_util::CopyResultsFromGetDataCallbackAndQuit,
                  &result_code,
                  &result_data));
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/files/gdata/testfile.txt?v=3&alt=json&showfolders=true"
             "&max-results=500&include-installed-apps=true",
             http_request_.relative_url);
   EXPECT_FALSE(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
-      base::Bind(&CopyResultsFromGetDataCallbackAndQuit,
+      base::Bind(&test_util::CopyResultsFromGetDataCallbackAndQuit,
                  &result_code,
                  &result_data));
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/feeds/default/private/full/file%3A2_file_resource_id"
             "?v=3&alt=json",
             http_request_.relative_url);
-  ASSERT_TRUE(result_data);
-  EXPECT_TRUE(VerifyJsonData(
+  EXPECT_TRUE(test_util::VerifyJsonData(
       test_util::GetTestFilePath("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
-      base::Bind(&CopyResultsFromGetDataCallbackAndQuit,
+      base::Bind(&test_util::CopyResultsFromGetDataCallbackAndQuit,
                  &result_code,
                  &result_data));
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/feeds/default/private/full/%3Cinvalid%3E?v=3&alt=json",
             http_request_.relative_url);
   ASSERT_FALSE(result_data);
 }
 
 TEST_F(GDataWapiOperationsTest, GetAccountMetadataOperation) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result_data;
 
   GetAccountMetadataOperation* operation = new GetAccountMetadataOperation(
       &operation_registry_,
       request_context_getter_.get(),
       *url_generator_,
-      base::Bind(&CopyResultsFromGetDataCallbackAndQuit,
+      base::Bind(&test_util::CopyResultsFromGetDataCallbackAndQuit,
                  &result_code,
                  &result_data));
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/feeds/metadata/default?v=3&alt=json&include-installed-apps=true",
             http_request_.relative_url);
-  EXPECT_TRUE(VerifyJsonData(
+  EXPECT_TRUE(test_util::VerifyJsonData(
       test_util::GetTestFilePath("gdata/account_metadata.json"),
       result_data.get()));
 }
 
 TEST_F(GDataWapiOperationsTest, DownloadFileOperation_ValidFile) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   std::string contents;
   DownloadFileOperation* operation = new DownloadFileOperation(
       &operation_registry_,
       request_context_getter_.get(),
       base::Bind(&CopyResultsFromDownloadActionCallbackAndQuit,
                  &result_code,
                  &contents),
       GetContentCallback(),
       test_server_.GetURL("/files/gdata/testfile.txt"),
       FilePath::FromUTF8Unsafe("/dummy/gdata/testfile.txt"),
       GetTestCachedFilePath(FilePath::FromUTF8Unsafe("cached_testfile.txt")));
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/files/gdata/testfile.txt", http_request_.relative_url);
 
   const FilePath expected_path =
       test_util::GetTestFilePath("gdata/testfile.txt");
   std::string expected_contents;
   file_util::ReadFileToString(expected_path, &expected_contents);
   EXPECT_EQ(expected_contents, contents);
 }
 
 TEST_F(GDataWapiOperationsTest, DownloadFileOperation_NonExistentFile) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   std::string contents;
   DownloadFileOperation* operation = new DownloadFileOperation(
       &operation_registry_,
       request_context_getter_.get(),
       base::Bind(&CopyResultsFromDownloadActionCallbackAndQuit,
                  &result_code,
                  &contents),
       GetContentCallback(),
       test_server_.GetURL("/files/gdata/no-such-file.txt"),
       FilePath::FromUTF8Unsafe("/dummy/gdata/no-such-file.txt"),
       GetTestCachedFilePath(
           FilePath::FromUTF8Unsafe("cache_no-such-file.txt")));
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/files/gdata/no-such-file.txt", http_request_.relative_url);
   // Do not verify the not found message.
 }
 
 TEST_F(GDataWapiOperationsTest, DeleteResourceOperation) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
 
   DeleteResourceOperation* operation = new DeleteResourceOperation(
       &operation_registry_,
       request_context_getter_.get(),
       base::Bind(&CopyResultFromEntryActionCallbackAndQuit,
                  &result_code),
       test_server_.GetURL(
           "/feeds/default/private/full/file:2_file_resource_id"));
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/feeds/default/private/full/file:2_file_resource_id?v=3&alt=json",
             http_request_.relative_url);
   EXPECT_EQ("*", 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_,
-      base::Bind(&CopyResultsFromGetDataCallbackAndQuit,
+      base::Bind(&test_util::CopyResultsFromGetDataCallbackAndQuit,
                  &result_code,
                  &result_data),
       test_server_.GetURL("/feeds/default/private/full/folder%3Aroot"),
       FILE_PATH_LITERAL("new directory"));
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/feeds/default/private/full/folder%3Aroot?v=3&alt=json",
             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"
             " <title>new directory</title>\n"
             "</entry>\n",
             http_request_.content);
 }
 
 TEST_F(GDataWapiOperationsTest, CopyHostedDocumentOperation) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result_data;
 
   // Copy a document with a new name "New Document".
   CopyHostedDocumentOperation* operation = new CopyHostedDocumentOperation(
       &operation_registry_,
       request_context_getter_.get(),
       *url_generator_,
-      base::Bind(&CopyResultsFromGetDataCallbackAndQuit,
+      base::Bind(&test_util::CopyResultsFromGetDataCallbackAndQuit,
                  &result_code,
                  &result_data),
       "document:5_document_resource_id",  // source resource ID
       FILE_PATH_LITERAL("New Document"));
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/feeds/default/private/full?v=3&alt=json",
             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"
@@ skipping 11 matching lines @@
   RenameResourceOperation* operation = new RenameResourceOperation(
       &operation_registry_,
       request_context_getter_.get(),
       base::Bind(&CopyResultFromEntryActionCallbackAndQuit,
                  &result_code),
       test_server_.GetURL(
           "/feeds/default/private/full/file:2_file_resource_id"),
       FILE_PATH_LITERAL("New File"));
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/feeds/default/private/full/file:2_file_resource_id?v=3&alt=json",
             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"
             " <title>New File</title>\n"
             "</entry>\n",
             http_request_.content);
 }
 
 TEST_F(GDataWapiOperationsTest, AuthorizeAppOperation_ValidFeed) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result_data;
 
   // Authorize an app with APP_ID to access to a document.
   AuthorizeAppOperation* operation = new AuthorizeAppOperation(
       &operation_registry_,
       request_context_getter_.get(),
-      base::Bind(&CopyResultsFromGetDataCallbackAndQuit,
+      base::Bind(&test_util::CopyResultsFromGetDataCallbackAndQuit,
                  &result_code,
                  &result_data),
       test_server_.GetURL(
           "/feeds/default/private/full/file:2_file_resource_id"),
       "APP_ID");
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/feeds/default/private/full/file:2_file_resource_id?v=3&alt=json",
             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"
             " <docs:authorizedApp>APP_ID</docs:authorizedApp>\n"
             "</entry>\n",
             http_request_.content);
 }
 
 TEST_F(GDataWapiOperationsTest, AuthorizeAppOperation_InvalidFeed) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result_data;
 
   // Authorize an app with APP_ID to access to a document but an invalid feed.
   AuthorizeAppOperation* operation = new AuthorizeAppOperation(
       &operation_registry_,
       request_context_getter_.get(),
-      base::Bind(&CopyResultsFromGetDataCallbackAndQuit,
+      base::Bind(&test_util::CopyResultsFromGetDataCallbackAndQuit,
                  &result_code,
                  &result_data),
       test_server_.GetURL("/files/gdata/testfile.txt"),
       "APP_ID");
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/files/gdata/testfile.txt?v=3&alt=json",
             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);
@@ skipping 14 matching lines @@
           &operation_registry_,
           request_context_getter_.get(),
           *url_generator_,
           base::Bind(&CopyResultFromEntryActionCallbackAndQuit,
                      &result_code),
           test_server_.GetURL("/feeds/default/private/full/folder%3Aroot"),
           test_server_.GetURL(
               "/feeds/default/private/full/file:2_file_resource_id"));
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/feeds/default/private/full/folder%3Aroot?v=3&alt=json",
             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"
@@ skipping 11 matching lines @@
   RemoveResourceFromDirectoryOperation* operation =
       new RemoveResourceFromDirectoryOperation(
           &operation_registry_,
           request_context_getter_.get(),
           base::Bind(&CopyResultFromEntryActionCallbackAndQuit,
                      &result_code),
           test_server_.GetURL("/feeds/default/private/full/folder%3Aroot"),
           "file:2_file_resource_id");
 
   operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&DoNothingForReAuthenticateCallback));
+                   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("/feeds/default/private/full/folder%3Aroot/"
             "file%3A2_file_resource_id?v=3&alt=json",
             http_request_.relative_url);
   EXPECT_EQ("*", http_request_.headers["If-Match"]);
   EXPECT_FALSE(http_request_.has_content);
@@ skipping 17 matching lines @@
       "" /* etag */);
 
   InitiateUploadOperation* initiate_operation = new InitiateUploadOperation(
       &operation_registry_,
       request_context_getter_.get(),
       base::Bind(&CopyResultFromInitiateUploadCallbackAndQuit,
                  &result_code,
                  &upload_url),
       initiate_params);
 
-  initiate_operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                            base::Bind(&DoNothingForReAuthenticateCallback));
+  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);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ("/feeds/upload/create-session/default/private/full"
             "?convert=false&v=3&alt=json",
             http_request_.relative_url);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
@@ skipping 25 matching lines @@
   scoped_ptr<ResourceEntry> new_entry;
 
   ResumeUploadOperation* resume_operation = new ResumeUploadOperation(
       &operation_registry_,
       request_context_getter_.get(),
       base::Bind(&CopyResultFromResumeUploadCallbackAndQuit,
                  &response,
                  &new_entry),
       resume_params);
 
-  resume_operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                          base::Bind(&DoNothingForReAuthenticateCallback));
+  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);
   // 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()),
@@ skipping 31 matching lines @@
       "" /* etag */);
 
   InitiateUploadOperation* initiate_operation = new InitiateUploadOperation(
       &operation_registry_,
       request_context_getter_.get(),
       base::Bind(&CopyResultFromInitiateUploadCallbackAndQuit,
                  &result_code,
                  &upload_url),
       initiate_params);
 
-  initiate_operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                            base::Bind(&DoNothingForReAuthenticateCallback));
+  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);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ("/feeds/upload/create-session/default/private/full?convert=false"
             "&v=3&alt=json",
             http_request_.relative_url);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
@@ skipping 38 matching lines @@
     scoped_ptr<ResourceEntry> new_entry;
 
     ResumeUploadOperation* resume_operation = new ResumeUploadOperation(
         &operation_registry_,
         request_context_getter_.get(),
         base::Bind(&CopyResultFromResumeUploadCallbackAndQuit,
                    &response,
                    &new_entry),
         resume_params);
 
-    resume_operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                            base::Bind(&DoNothingForReAuthenticateCallback));
+    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);
     // 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) + "/" +
@@ skipping 43 matching lines @@
       "" /* etag */);
 
   InitiateUploadOperation* initiate_operation = new InitiateUploadOperation(
       &operation_registry_,
       request_context_getter_.get(),
       base::Bind(&CopyResultFromInitiateUploadCallbackAndQuit,
                  &result_code,
                  &upload_url),
       initiate_params);
 
-  initiate_operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                            base::Bind(&DoNothingForReAuthenticateCallback));
+  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);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ("/feeds/upload/create-session/default/private/full?convert=false"
             "&v=3&alt=json",
             http_request_.relative_url);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
@@ skipping 25 matching lines @@
   scoped_ptr<ResourceEntry> new_entry;
 
   ResumeUploadOperation* resume_operation = new ResumeUploadOperation(
       &operation_registry_,
       request_context_getter_.get(),
       base::Bind(&CopyResultFromResumeUploadCallbackAndQuit,
                  &response,
                  &new_entry),
       resume_params);
 
-  resume_operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                          base::Bind(&DoNothingForReAuthenticateCallback));
+  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);
   // 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.
@@ skipping 26 matching lines @@
       "" /* etag */);
 
   InitiateUploadOperation* initiate_operation = new InitiateUploadOperation(
       &operation_registry_,
       request_context_getter_.get(),
       base::Bind(&CopyResultFromInitiateUploadCallbackAndQuit,
                  &result_code,
                  &upload_url),
       initiate_params);
 
-  initiate_operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                            base::Bind(&DoNothingForReAuthenticateCallback));
+  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);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ("/feeds/upload/create-session/default/private/full/file:foo"
             "?convert=false&v=3&alt=json",
             http_request_.relative_url);
@@ skipping 25 matching lines @@
   scoped_ptr<ResourceEntry> new_entry;
 
   ResumeUploadOperation* resume_operation = new ResumeUploadOperation(
       &operation_registry_,
       request_context_getter_.get(),
       base::Bind(&CopyResultFromResumeUploadCallbackAndQuit,
                  &response,
                  &new_entry),
       resume_params);
 
-  resume_operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                          base::Bind(&DoNothingForReAuthenticateCallback));
+  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);
   // 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()),
@@ skipping 28 matching lines @@
       kTestETag);
 
   InitiateUploadOperation* initiate_operation = new InitiateUploadOperation(
       &operation_registry_,
       request_context_getter_.get(),
       base::Bind(&CopyResultFromInitiateUploadCallbackAndQuit,
                  &result_code,
                  &upload_url),
       initiate_params);
 
-  initiate_operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                            base::Bind(&DoNothingForReAuthenticateCallback));
+  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);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ("/feeds/upload/create-session/default/private/full/file:foo"
             "?convert=false&v=3&alt=json",
             http_request_.relative_url);
@@ skipping 25 matching lines @@
   scoped_ptr<ResourceEntry> new_entry;
 
   ResumeUploadOperation* resume_operation = new ResumeUploadOperation(
       &operation_registry_,
       request_context_getter_.get(),
       base::Bind(&CopyResultFromResumeUploadCallbackAndQuit,
                  &response,
                  &new_entry),
       resume_params);
 
-  resume_operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                          base::Bind(&DoNothingForReAuthenticateCallback));
+  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);
   // 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()),
@@ skipping 28 matching lines @@
       kWrongETag);
 
   InitiateUploadOperation* initiate_operation = new InitiateUploadOperation(
       &operation_registry_,
       request_context_getter_.get(),
       base::Bind(&CopyResultFromInitiateUploadCallbackAndQuit,
                  &result_code,
                  &upload_url),
       initiate_params);
 
-  initiate_operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                            base::Bind(&DoNothingForReAuthenticateCallback));
+  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);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ("/feeds/upload/create-session/default/private/full/file:foo"
             "?convert=false&v=3&alt=json",
             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