Sync FileSystem: Use app id part of the URL for its directory title.

chrome/browser/sync_file_system/drive_file_sync_service_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_service.h"
 
 #include <utility>
 
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 368 matching lines @@
 
   EXPECT_EQ("folder:sync_root_resource_id",
             metadata_store()->sync_root_directory());
 
   EXPECT_EQ(0u, metadata_store()->batch_sync_origins().size());
   EXPECT_EQ(0u, metadata_store()->incremental_sync_origins().size());
   EXPECT_EQ(0u, pending_changes().size());
 }
 
 TEST_F(DriveFileSyncServiceTest, BatchSyncOnInitialization) {
-  const GURL kOrigin1("http://example.com");
-  const GURL kOrigin2("http://hoge.example.com");
+  const GURL kOrigin1("chrome-extension://example.com");
+  const GURL kOrigin2("chrome-extension://hoge.example.com");

[kinuko, 2012/11/30 07:13:28]

could we also replace the host part with more plausible ones? (e.g. 'example' or
'hoge')

[tzik, 2012/12/03 08:12:08]

Done.

   const std::string kDirectoryResourceId1(
       "folder:origin_directory_resource_id");
   const std::string kDirectoryResourceId2(
       "folder:origin_directory_resource_id2");
   const std::string kSyncRootResourceId("folder:sync_root_resource_id");
 
   metadata_store()->SetSyncRootDirectory(kSyncRootResourceId);
   metadata_store()->AddBatchSyncOrigin(kOrigin1, kDirectoryResourceId1);
   metadata_store()->AddBatchSyncOrigin(kOrigin2, kDirectoryResourceId2);
   metadata_store()->MoveBatchSyncOriginToIncremental(kOrigin2);
@@ skipping 31 matching lines @@
   // kOrigin1 should be a batch sync origin and kOrigin2 should be an
   // incremental sync origin.
   // 4 pending remote changes are from listing_files_in_directory as batch sync
   // changes.
   EXPECT_EQ(1u, metadata_store()->batch_sync_origins().size());
   EXPECT_EQ(1u, metadata_store()->incremental_sync_origins().size());
   EXPECT_EQ(4u, pending_changes().size());
 }
 
 TEST_F(DriveFileSyncServiceTest, RegisterNewOrigin) {
-  const GURL kOrigin("http://example.com");
+  const GURL kOrigin("chrome-extension://example.com");
   const std::string kDirectoryResourceId("folder:origin_directory_resource_id");
   const std::string kSyncRootResourceId("folder:sync_root_resource_id");
   const GURL kSyncRootContentURL("https://sync_root_content_url/");
 
   metadata_store()->SetSyncRootDirectory(kSyncRootResourceId);
 
   EXPECT_CALL(*mock_remote_observer(),
               OnRemoteServiceStateUpdated(REMOTE_SERVICE_OK, _))
       .Times(AtLeast(1));
   EXPECT_CALL(*mock_remote_observer(), OnRemoteChangeAvailable(0))
       .Times(AnyNumber());
 
   InSequence sequence;
 
   scoped_ptr<Value> origin_directory_not_found(LoadJSONFile(
       "sync_file_system/origin_directory_not_found.json"));
-  std::string query = FormatTitleQuery(kOrigin.spec());
+  std::string query = FormatTitleQuery(
+      DriveFileSyncClient::OriginToDirectoryTitle(kOrigin));
 
   EXPECT_CALL(*mock_drive_service(),
               GetDocuments(GURL(), 0, query, false, kSyncRootResourceId, _))
       .WillOnce(InvokeGetDataCallback5(
           google_apis::HTTP_SUCCESS,
           base::Passed(&origin_directory_not_found)))
       .RetiresOnSaturation();
 
   // If the directory for the origin is missing, DriveFileSyncService should
   // attempt to create it. And as a preparation, it should fetch the content url
   // of the parent directory.
   //
   // |sync_root_entry| contains kSyncRootContentURL which is to be added as
   // a new origin directory under the root directory.
   scoped_ptr<Value> sync_root_entry(LoadJSONFile(
       "sync_file_system/sync_root_entry.json"));
   EXPECT_CALL(*mock_drive_service(),
               GetDocumentEntry(kSyncRootResourceId, _))
       .WillOnce(InvokeGetDataCallback1(
           google_apis::HTTP_SUCCESS,
           base::Passed(&sync_root_entry)));
 
   scoped_ptr<Value> origin_directory_created(LoadJSONFile(
       "sync_file_system/origin_directory_created.json"));
-  FilePath::StringType dirname =
-      FilePath().AppendASCII(kOrigin.spec()).value();
+  FilePath::StringType dirname = FilePath().AppendASCII(
+      DriveFileSyncClient::OriginToDirectoryTitle(kOrigin)).value();
   EXPECT_CALL(*mock_drive_service(),
               AddNewDirectory(kSyncRootContentURL, dirname, _))
       .WillOnce(InvokeGetDataCallback2(
           google_apis::HTTP_SUCCESS,
           base::Passed(&origin_directory_created)));
 
   // Once the directory is created GetAccountMetadata should be called to get
   // the largest changestamp for the origin as a prepariation of the batch sync.
   scoped_ptr<Value> account_metadata(LoadJSONFile(
       "gdata/account_metadata.json"));
@@ skipping 17 matching lines @@
       kOrigin, base::Bind(&ExpectEqStatus, &done, fileapi::SYNC_STATUS_OK));
   message_loop()->RunUntilIdle();
   EXPECT_TRUE(done);
 
   EXPECT_EQ(1u, metadata_store()->batch_sync_origins().size());
   EXPECT_TRUE(metadata_store()->incremental_sync_origins().empty());
   EXPECT_TRUE(pending_changes().empty());
 }
 
 TEST_F(DriveFileSyncServiceTest, RegisterExistingOrigin) {
-  const GURL kOrigin("http://example.com");
+  const GURL kOrigin("chrome-extension://example.com");
   const std::string kDirectoryResourceId("folder:origin_directory_resource_id");
   const std::string kSyncRootResourceId("folder:sync_root_resource_id");
 
   metadata_store()->SetSyncRootDirectory(kSyncRootResourceId);
 
   EXPECT_CALL(*mock_remote_observer(),
               OnRemoteServiceStateUpdated(REMOTE_SERVICE_OK, _))
       .Times(AtLeast(1));
   EXPECT_CALL(*mock_remote_observer(), OnRemoteChangeAvailable(4))
       .Times(AnyNumber());
 
   InSequence sequence;
 
   scoped_ptr<Value> origin_directory_found(LoadJSONFile(
       "sync_file_system/origin_directory_found.json"));
-  std::string query = FormatTitleQuery("http://example.com/");
+  std::string query = FormatTitleQuery(
+      DriveFileSyncClient::OriginToDirectoryTitle(kOrigin));
   EXPECT_CALL(*mock_drive_service(),
               GetDocuments(GURL(), 0, query, false, kSyncRootResourceId, _))
       .WillOnce(InvokeGetDataCallback5(
           google_apis::HTTP_SUCCESS,
           base::Passed(&origin_directory_found)))
       .RetiresOnSaturation();
 
   scoped_ptr<Value> account_metadata(LoadJSONFile(
       "gdata/account_metadata.json"));
   EXPECT_CALL(*mock_drive_service(), GetAccountMetadata(_))
@@ skipping 79 matching lines @@
   message_loop()->RunUntilIdle();
   EXPECT_TRUE(done);
 
   EXPECT_TRUE(metadata_store()->batch_sync_origins().empty());
   EXPECT_EQ(1u, metadata_store()->incremental_sync_origins().size());
   EXPECT_TRUE(pending_changes().empty());
 }
 
 TEST_F(DriveFileSyncServiceTest, ResolveSyncOperationType) {
   const fileapi::FileSystemURL url = fileapi::CreateSyncableFileSystemURL(
-      GURL("http://example.com/"),
+      GURL("chrome-extension://example.com/"),
       DriveFileSyncService::kServiceName,
       FilePath().AppendASCII("path/to/file"));
   const std::string kResourceId("123456");
   const int64 kChangestamp = 654321;
 
   scoped_ptr<Value> sync_root_found(LoadJSONFile(
       "sync_file_system/sync_root_found.json"));
   std::string query = FormatTitleQuery(kSyncRootDirectoryName);
   EXPECT_CALL(*mock_drive_service(),
               GetDocuments(GURL(), 0, query, false, std::string(), _))
@@ skipping 201 matching lines @@
       *LoadJSONFile("gdata/file_entry.json")));
   AppendIncrementalRemoteChange(kOrigin, entry.get(), 12345);
   ProcessRemoteChange(fileapi::SYNC_STATUS_OK,
                       CreateURL(kOrigin, kFileName),
                       fileapi::SYNC_OPERATION_UPDATE);
 }
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace sync_file_system