Implement polling part of DriveFileSyncService

chrome/browser/sync_file_system/drive_file_sync_client_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 "chrome/browser/sync_file_system/drive_file_sync_client.h"
 
 #include "base/json/json_reader.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "chrome/browser/google_apis/drive_uploader.h"
@@ skipping 121 matching lines @@
   }
 
   virtual void SetUp() OVERRIDE {
     mock_drive_service_ = new StrictMock<MockDriveService>;
     fake_drive_uploader_ = new FakeDriveUploader;
 
     EXPECT_CALL(*mock_drive_service_, Initialize(&profile_)).Times(1);
 
     sync_client_ = DriveFileSyncClient::CreateForTesting(
         &profile_,
+        GURL(google_apis::GDataWapiUrlGenerator::kBaseUrlForProduction),
         scoped_ptr<DriveServiceInterface>(mock_drive_service_),
         scoped_ptr<DriveUploaderInterface>(fake_drive_uploader_)).Pass();
   }
 
   virtual void TearDown() OVERRIDE {
     EXPECT_CALL(*mock_drive_service(), CancelAll());
     sync_client_.reset();
   }
 
  protected:
   DriveFileSyncClient* sync_client() { return sync_client_.get(); }
 
+  std::string FormatOriginQuery(const GURL& origin) {
+    return FormatTitleQuery(
+        DriveFileSyncClient::OriginToDirectoryTitle(origin));
+  }
+
   std::string FormatTitleQuery(const std::string& title) {
     return DriveFileSyncClient::FormatTitleQuery(title);
   }
 
   StrictMock<MockDriveService>* mock_drive_service() {
     return mock_drive_service_;
   }
 
   MessageLoop* message_loop() { return &message_loop_; }
 
@@ skipping 181 matching lines @@
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_CREATED, error);
   EXPECT_EQ("folder:sync_root_resource_id", resource_id);
 }
 
 TEST_F(DriveFileSyncClientTest, GetOriginDirectory) {
   const std::string kParentResourceId("folder:sync_root_resource_id");
   const std::string kOriginDirectoryResourceId(
       "folder:origin_directory_resource_id");
-  const GURL kOrigin("http://example.com");
+  const GURL kOrigin("chrome-extension://example");
 
   scoped_ptr<base::Value> found_result(google_apis::test_util::LoadJSONFile(
       "sync_file_system/origin_directory_found.json").Pass());
 
   // Expected to call GetDocuments from GetDriveDirectoryForOrigin.
   EXPECT_CALL(*mock_drive_service(),
               GetDocuments(GURL(),  // feed_url
                            0,       // start_changestamp
-                           FormatTitleQuery(kOrigin.spec()),
+                           FormatOriginQuery(kOrigin),
                            false,   // shared_with_me
                            kParentResourceId,
                            _))
       .WillOnce(InvokeGetDataCallback5(google_apis::HTTP_SUCCESS,
                                        base::Passed(&found_result)));
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   sync_client()->GetDriveDirectoryForOrigin(
       kParentResourceId, kOrigin,
       base::Bind(&DidGetResourceID, &done, &error, &resource_id));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
   EXPECT_EQ(kOriginDirectoryResourceId, resource_id);
 }
 
 TEST_F(DriveFileSyncClientTest, CreateOriginDirectory) {
   const std::string kParentResourceId("folder:sync_root_resource_id");
-  const GURL kOrigin("http://example.com");
+  const GURL kOrigin("chrome-extension://example");
 
   scoped_ptr<base::Value> not_found_result(google_apis::test_util::LoadJSONFile(
       "sync_file_system/origin_directory_not_found.json").Pass());
   scoped_ptr<base::Value> got_parent_result(
       google_apis::test_util::LoadJSONFile(
           "sync_file_system/origin_directory_get_parent.json").Pass());
   scoped_ptr<base::Value> created_result(google_apis::test_util::LoadJSONFile(
       "sync_file_system/origin_directory_created.json").Pass());
 
   testing::InSequence sequence;
 
   // Expected to call GetDocuments from GetDriveDirectoryForOrigin.
   EXPECT_CALL(*mock_drive_service(),
               GetDocuments(GURL(),             // feed_url
                            0,                  // start_changestamp
-                           FormatTitleQuery(kOrigin.spec()),
+                           FormatOriginQuery(kOrigin),
                            false,              // shared_with_me
                            kParentResourceId,  // directory_resource_id
                            _))
       .WillOnce(InvokeGetDataCallback5(google_apis::HTTP_SUCCESS,
                                        base::Passed(&not_found_result)));
 
   // Expected to call GetDocumentEntry from GetDriveDirectoryForOrigin.
   EXPECT_CALL(*mock_drive_service(),
               GetDocumentEntry(kParentResourceId, _))
       .WillOnce(InvokeGetDataCallback1(google_apis::HTTP_SUCCESS,
                                        base::Passed(&got_parent_result)));
 
+  std::string dir_title(DriveFileSyncClient::OriginToDirectoryTitle(kOrigin));
   // Expected to call AddNewDirectory from GetDriveDirectoryForOrigin.
   EXPECT_CALL(*mock_drive_service(),
               AddNewDirectory(GURL("https://sync_root_content_url"),
-                              FilePath().AppendASCII(kOrigin.spec()).value(),
+                              FilePath().AppendASCII(dir_title).value(),
                               _))
       .WillOnce(InvokeGetDataCallback2(google_apis::HTTP_CREATED,
                                        base::Passed(&created_result)));
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   sync_client()->GetDriveDirectoryForOrigin(
       kParentResourceId, kOrigin,
       base::Bind(&DidGetResourceID, &done, &error, &resource_id));
@@ skipping 409 matching lines @@
                             base::Bind(&DidDeleteFile, &done, &error));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_CONFLICT, error);
 }
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace sync_file_system