Home | History | Annotate | Download | only in drive_backend_v1 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/sync_file_system/drive_backend_v1/drive_metadata_store.h"
      6 
      7 #include <utility>
      8 
      9 #include "base/files/file_path.h"
     10 #include "base/files/scoped_temp_dir.h"
     11 #include "base/message_loop/message_loop.h"
     12 #include "base/single_thread_task_runner.h"
     13 #include "base/stl_util.h"
     14 #include "base/strings/string_number_conversions.h"
     15 #include "base/strings/string_util.h"
     16 #include "base/threading/thread.h"
     17 #include "base/values.h"
     18 #include "chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util.h"
     19 #include "chrome/browser/sync_file_system/drive_backend_v1/drive_file_sync_service.h"
     20 #include "chrome/browser/sync_file_system/drive_backend_v1/drive_file_sync_util.h"
     21 #include "chrome/browser/sync_file_system/sync_file_system.pb.h"
     22 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
     23 #include "content/public/browser/browser_thread.h"
     24 #include "testing/gtest/include/gtest/gtest.h"
     25 #include "third_party/leveldatabase/src/include/leveldb/db.h"
     26 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
     27 #include "webkit/browser/fileapi/isolated_context.h"
     28 
     29 #define FPL FILE_PATH_LITERAL
     30 
     31 using content::BrowserThread;
     32 
     33 namespace sync_file_system {
     34 
     35 namespace {
     36 
     37 const char kOrigin[] = "chrome-extension://example";
     38 
     39 typedef DriveMetadataStore::ResourceIdByOrigin ResourceIdByOrigin;
     40 typedef DriveMetadataStore::OriginByResourceId OriginByResourceId;
     41 
     42 fileapi::FileSystemURL URL(const base::FilePath& path) {
     43   return CreateSyncableFileSystemURL(GURL(kOrigin), path);
     44 }
     45 
     46 std::string GetResourceID(const ResourceIdByOrigin& sync_origins,
     47                           const GURL& origin) {
     48   ResourceIdByOrigin::const_iterator itr = sync_origins.find(origin);
     49   if (itr == sync_origins.end())
     50     return std::string();
     51   return itr->second;
     52 }
     53 
     54 std::string CreateResourceId(const std::string& resource_id) {
     55   return IsDriveAPIDisabled() ? resource_id
     56                               : drive_backend::RemoveWapiIdPrefix(resource_id);
     57 }
     58 
     59 DriveMetadata CreateMetadata(const std::string& resource_id,
     60                              const std::string& md5_checksum,
     61                              bool conflicted,
     62                              bool to_be_fetched,
     63                              DriveMetadata_ResourceType file_type) {
     64   DriveMetadata metadata;
     65   metadata.set_resource_id(CreateResourceId(resource_id));
     66   metadata.set_md5_checksum(md5_checksum);
     67   metadata.set_conflicted(conflicted);
     68   metadata.set_to_be_fetched(to_be_fetched);
     69   metadata.set_type(file_type);
     70   return metadata;
     71 }
     72 
     73 }  // namespace
     74 
     75 class DriveMetadataStoreTest : public testing::Test {
     76  public:
     77   DriveMetadataStoreTest()
     78       : created_(false) {}
     79 
     80   virtual ~DriveMetadataStoreTest() {}
     81 
     82   virtual void SetUp() OVERRIDE {
     83     file_thread_.reset(new base::Thread("Thread_File"));
     84     file_thread_->Start();
     85 
     86     ui_task_runner_ = base::MessageLoopProxy::current();
     87     file_task_runner_ = file_thread_->message_loop_proxy();
     88 
     89     ASSERT_TRUE(base_dir_.CreateUniqueTempDir());
     90     RegisterSyncableFileSystem();
     91   }
     92 
     93   virtual void TearDown() OVERRIDE {
     94     SetDisableDriveAPI(false);
     95     RevokeSyncableFileSystem();
     96 
     97     DropDatabase();
     98     file_thread_->Stop();
     99     message_loop_.RunUntilIdle();
    100   }
    101 
    102  protected:
    103   void InitializeDatabase() {
    104     EXPECT_TRUE(ui_task_runner_->RunsTasksOnCurrentThread());
    105 
    106     bool done = false;
    107     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
    108     bool created = false;
    109 
    110     drive_metadata_store_.reset(
    111         new DriveMetadataStore(base_dir_.path(), file_task_runner_.get()));
    112     drive_metadata_store_->Initialize(
    113         base::Bind(&DriveMetadataStoreTest::DidInitializeDatabase,
    114                    base::Unretained(this),
    115                    &done,
    116                    &status,
    117                    &created));
    118     message_loop_.Run();
    119 
    120     EXPECT_TRUE(done);
    121     EXPECT_EQ(SYNC_STATUS_OK, status);
    122 
    123     if (created) {
    124       EXPECT_FALSE(created_);
    125       created_ = created;
    126       return;
    127     }
    128     EXPECT_TRUE(created_);
    129   }
    130 
    131   void DropDatabase() {
    132     EXPECT_TRUE(ui_task_runner_->RunsTasksOnCurrentThread());
    133     drive_metadata_store_.reset();
    134   }
    135 
    136   SyncStatusCode EnableOrigin(const GURL& origin) {
    137     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
    138     drive_metadata_store_->EnableOrigin(
    139         origin, base::Bind(&DriveMetadataStoreTest::DidFinishDBTask,
    140                            base::Unretained(this), &status));
    141     message_loop_.Run();
    142     return status;
    143   }
    144 
    145   SyncStatusCode DisableOrigin(const GURL& origin) {
    146     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
    147     drive_metadata_store_->DisableOrigin(
    148         origin, base::Bind(&DriveMetadataStoreTest::DidFinishDBTask,
    149                            base::Unretained(this), &status));
    150     message_loop_.Run();
    151     return status;
    152   }
    153 
    154   SyncStatusCode RemoveOrigin(const GURL& url) {
    155     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
    156     drive_metadata_store_->RemoveOrigin(
    157         url, base::Bind(&DriveMetadataStoreTest::DidFinishDBTask,
    158                         base::Unretained(this), &status));
    159     message_loop_.Run();
    160     return status;
    161   }
    162 
    163   SyncStatusCode UpdateEntry(const fileapi::FileSystemURL& url,
    164                              const DriveMetadata& metadata) {
    165     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
    166     drive_metadata_store_->UpdateEntry(
    167         url, metadata,
    168         base::Bind(&DriveMetadataStoreTest::DidFinishDBTask,
    169                    base::Unretained(this), &status));
    170     message_loop_.Run();
    171     return status;
    172   }
    173 
    174   SyncStatusCode DeleteEntry(const fileapi::FileSystemURL& url) {
    175     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
    176     drive_metadata_store_->DeleteEntry(
    177         url,
    178         base::Bind(&DriveMetadataStoreTest::DidFinishDBTask,
    179                    base::Unretained(this), &status));
    180     message_loop_.Run();
    181     return status;
    182   }
    183 
    184   SyncStatusCode SetLargestChangeStamp(int64 changestamp) {
    185     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
    186     drive_metadata_store_->SetLargestChangeStamp(
    187         changestamp, base::Bind(&DriveMetadataStoreTest::DidFinishDBTask,
    188                                 base::Unretained(this), &status));
    189     message_loop_.Run();
    190     return status;
    191   }
    192 
    193   void DidFinishDBTask(SyncStatusCode* status_out,
    194                        SyncStatusCode status) {
    195     *status_out = status;
    196     message_loop_.Quit();
    197   }
    198 
    199   void MarkAsCreated() {
    200     created_ = true;
    201   }
    202 
    203   void VerifyUntrackedOrigin(const GURL& origin) {
    204     EXPECT_FALSE(metadata_store()->IsIncrementalSyncOrigin(origin));
    205     EXPECT_FALSE(metadata_store()->IsOriginDisabled(origin));
    206   }
    207 
    208   void VerifyIncrementalSyncOrigin(const GURL& origin,
    209                                    const std::string& resource_id) {
    210     EXPECT_TRUE(metadata_store()->IsIncrementalSyncOrigin(origin));
    211     EXPECT_FALSE(metadata_store()->IsOriginDisabled(origin));
    212     EXPECT_EQ(resource_id,
    213               GetResourceID(metadata_store()->incremental_sync_origins(),
    214                             origin));
    215   }
    216 
    217   void VerifyDisabledOrigin(const GURL& origin,
    218                             const std::string& resource_id) {
    219     EXPECT_FALSE(metadata_store()->IsIncrementalSyncOrigin(origin));
    220     EXPECT_TRUE(metadata_store()->IsOriginDisabled(origin));
    221     EXPECT_EQ(resource_id,
    222               GetResourceID(metadata_store()->disabled_origins(), origin));
    223   }
    224 
    225   DriveMetadataStore* metadata_store() {
    226     return drive_metadata_store_.get();
    227   }
    228 
    229   const DriveMetadataStore::MetadataMap& metadata_map() {
    230     return drive_metadata_store_->metadata_map_;
    231   }
    232 
    233   void VerifyReverseMap() {
    234     const ResourceIdByOrigin& incremental_sync_origins =
    235         drive_metadata_store_->incremental_sync_origins_;
    236     const ResourceIdByOrigin& disabled_origins =
    237         drive_metadata_store_->disabled_origins_;
    238     const OriginByResourceId& origin_by_resource_id =
    239         drive_metadata_store_->origin_by_resource_id_;
    240 
    241     size_t expected_size = incremental_sync_origins.size() +
    242                            disabled_origins.size();
    243     size_t actual_size = origin_by_resource_id.size();
    244     EXPECT_EQ(expected_size, actual_size);
    245     EXPECT_TRUE(VerifyReverseMapInclusion(incremental_sync_origins,
    246                                           origin_by_resource_id));
    247     EXPECT_TRUE(VerifyReverseMapInclusion(disabled_origins,
    248                                           origin_by_resource_id));
    249   }
    250 
    251   void ReadWrite_Body();
    252   void GetConflictURLs_Body();
    253   void GetToBeFetchedFiles_Body();
    254   void StoreSyncRootDirectory_Body();
    255   void StoreSyncOrigin_Body();
    256   void DisableOrigin_Body();
    257   void RemoveOrigin_Body();
    258   void GetResourceIdForOrigin_Body();
    259   void ResetOriginRootDirectory_Body();
    260   void GetFileMetadataMap_Body();
    261 
    262  private:
    263   void DidInitializeDatabase(bool* done_out,
    264                              SyncStatusCode* status_out,
    265                              bool* created_out,
    266                              SyncStatusCode status,
    267                              bool created) {
    268     *done_out = true;
    269     *status_out = status;
    270     *created_out = created;
    271     message_loop_.Quit();
    272   }
    273 
    274   bool VerifyReverseMapInclusion(const ResourceIdByOrigin& left,
    275                                  const OriginByResourceId& right) {
    276     for (ResourceIdByOrigin::const_iterator itr = left.begin();
    277          itr != left.end(); ++itr) {
    278       OriginByResourceId::const_iterator found = right.find(itr->second);
    279       if (found == right.end() || found->second != itr->first)
    280         return false;
    281     }
    282     return true;
    283   }
    284 
    285   base::ScopedTempDir base_dir_;
    286 
    287   base::MessageLoop message_loop_;
    288   scoped_ptr<base::Thread> file_thread_;
    289 
    290   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
    291   scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
    292 
    293   scoped_ptr<DriveMetadataStore> drive_metadata_store_;
    294 
    295   bool created_;
    296 
    297   DISALLOW_COPY_AND_ASSIGN(DriveMetadataStoreTest);
    298 };
    299 
    300 void DriveMetadataStoreTest::ReadWrite_Body() {
    301   InitializeDatabase();
    302 
    303   const fileapi::FileSystemURL url = URL(base::FilePath());
    304   DriveMetadata metadata;
    305   EXPECT_EQ(SYNC_DATABASE_ERROR_NOT_FOUND,
    306             metadata_store()->ReadEntry(url, &metadata));
    307 
    308   metadata = CreateMetadata(
    309       "file:1234567890", "09876543210", true, false,
    310       DriveMetadata_ResourceType_RESOURCE_TYPE_FILE);
    311   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(url, metadata));
    312   EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1));
    313 
    314   DropDatabase();
    315   InitializeDatabase();
    316 
    317   EXPECT_EQ(1, metadata_store()->GetLargestChangeStamp());
    318 
    319   DriveMetadata metadata2;
    320   EXPECT_EQ(SYNC_STATUS_OK,
    321             metadata_store()->ReadEntry(url, &metadata2));
    322   EXPECT_EQ(metadata.resource_id(), metadata2.resource_id());
    323   EXPECT_EQ(metadata.md5_checksum(), metadata2.md5_checksum());
    324   EXPECT_EQ(metadata.conflicted(), metadata2.conflicted());
    325 
    326   EXPECT_EQ(SYNC_STATUS_OK, DeleteEntry(url));
    327   EXPECT_EQ(SYNC_DATABASE_ERROR_NOT_FOUND,
    328             metadata_store()->ReadEntry(url, &metadata));
    329   EXPECT_EQ(SYNC_DATABASE_ERROR_NOT_FOUND, DeleteEntry(url));
    330 
    331   VerifyReverseMap();
    332 }
    333 
    334 void DriveMetadataStoreTest::GetConflictURLs_Body() {
    335   InitializeDatabase();
    336 
    337   fileapi::FileSystemURLSet urls;
    338   EXPECT_EQ(SYNC_STATUS_OK, metadata_store()->GetConflictURLs(&urls));
    339   EXPECT_EQ(0U, urls.size());
    340 
    341   const base::FilePath path1(FPL("file1"));
    342   const base::FilePath path2(FPL("file2"));
    343   const base::FilePath path3(FPL("file3"));
    344 
    345   // Populate metadata in DriveMetadataStore. The metadata identified by "file2"
    346   // and "file3" are marked as conflicted.
    347   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
    348       URL(path1),
    349       CreateMetadata("file:1", "1", false, false,
    350                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
    351   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
    352       URL(path2),
    353       CreateMetadata("file:2", "2", true, false,
    354                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
    355   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
    356       URL(path3),
    357       CreateMetadata("file:3", "3", true, false,
    358                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
    359 
    360   EXPECT_EQ(SYNC_STATUS_OK, metadata_store()->GetConflictURLs(&urls));
    361   EXPECT_EQ(2U, urls.size());
    362   EXPECT_FALSE(ContainsKey(urls, URL(path1)));
    363   EXPECT_TRUE(ContainsKey(urls, URL(path2)));
    364   EXPECT_TRUE(ContainsKey(urls, URL(path3)));
    365 
    366   VerifyReverseMap();
    367 }
    368 
    369 void DriveMetadataStoreTest::GetToBeFetchedFiles_Body() {
    370   InitializeDatabase();
    371 
    372   DriveMetadataStore::URLAndDriveMetadataList list;
    373   EXPECT_EQ(SYNC_STATUS_OK, metadata_store()->GetToBeFetchedFiles(&list));
    374   EXPECT_TRUE(list.empty());
    375 
    376   const base::FilePath path1(FPL("file1"));
    377   const base::FilePath path2(FPL("file2"));
    378   const base::FilePath path3(FPL("file3"));
    379 
    380   // Populate metadata in DriveMetadataStore. The metadata identified by "file2"
    381   // and "file3" are marked to be fetched.
    382   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
    383       URL(path1),
    384       CreateMetadata("file:1", "1", false, false,
    385                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
    386   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
    387       URL(path2),
    388       CreateMetadata("file:2", "2", false, true,
    389                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
    390   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
    391       URL(path3),
    392       CreateMetadata("file:3", "3", false, true,
    393                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
    394 
    395   EXPECT_EQ(SYNC_STATUS_OK,
    396             metadata_store()->GetToBeFetchedFiles(&list));
    397   EXPECT_EQ(2U, list.size());
    398   EXPECT_EQ(list[0].first, URL(path2));
    399   EXPECT_EQ(list[1].first, URL(path3));
    400 
    401   VerifyReverseMap();
    402 }
    403 
    404 void DriveMetadataStoreTest::StoreSyncRootDirectory_Body() {
    405   const std::string kResourceId(CreateResourceId("folder:hoge"));
    406 
    407   InitializeDatabase();
    408   EXPECT_TRUE(metadata_store()->sync_root_directory().empty());
    409 
    410   metadata_store()->SetSyncRootDirectory(kResourceId);
    411   EXPECT_EQ(kResourceId, metadata_store()->sync_root_directory());
    412 
    413   DropDatabase();
    414   InitializeDatabase();
    415   EXPECT_EQ(kResourceId, metadata_store()->sync_root_directory());
    416 }
    417 
    418 void DriveMetadataStoreTest::StoreSyncOrigin_Body() {
    419   const GURL kOrigin1("chrome-extension://example1");
    420   const GURL kOrigin2("chrome-extension://example2");
    421   const std::string kResourceId1(CreateResourceId("folder:hoge"));
    422   const std::string kResourceId2(CreateResourceId("folder:fuga"));
    423 
    424   InitializeDatabase();
    425 
    426   // Make sure origins have not been marked yet.
    427   VerifyUntrackedOrigin(kOrigin1);
    428   VerifyUntrackedOrigin(kOrigin2);
    429 
    430   // Mark origins as incremental sync origins.
    431   metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1);
    432   metadata_store()->AddIncrementalSyncOrigin(kOrigin2, kResourceId2);
    433   VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1);
    434   VerifyIncrementalSyncOrigin(kOrigin2, kResourceId2);
    435 
    436   // Disabled origin 2, origin 1 should still be incremental.
    437   DisableOrigin(kOrigin2);
    438   VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1);
    439   VerifyDisabledOrigin(kOrigin2, kResourceId2);
    440 
    441   DropDatabase();
    442   InitializeDatabase();
    443 
    444   // Make sure origins have been restored.
    445   VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1);
    446   VerifyDisabledOrigin(kOrigin2, kResourceId2);
    447 
    448   VerifyReverseMap();
    449 }
    450 
    451 void DriveMetadataStoreTest::DisableOrigin_Body() {
    452   const GURL kOrigin1("chrome-extension://example1");
    453   const std::string kResourceId1(CreateResourceId("folder:hoge"));
    454 
    455   InitializeDatabase();
    456   EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1));
    457 
    458   metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1);
    459   VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1);
    460 
    461   DisableOrigin(kOrigin1);
    462   VerifyDisabledOrigin(kOrigin1, kResourceId1);
    463 
    464   // Re-enabled origins go back to DriveFileSyncService and are not tracked
    465   // in DriveMetadataStore.
    466   EnableOrigin(kOrigin1);
    467   VerifyUntrackedOrigin(kOrigin1);
    468 }
    469 
    470 void DriveMetadataStoreTest::RemoveOrigin_Body() {
    471   const GURL kOrigin1("chrome-extension://example1");
    472   const GURL kOrigin2("chrome-extension://example2");
    473   const GURL kOrigin3("chrome-extension://example3");
    474   const std::string kResourceId1(CreateResourceId("folder:hogera"));
    475   const std::string kResourceId2(CreateResourceId("folder:fugaga"));
    476   const std::string kResourceId3(CreateResourceId("folder:piyopiyo"));
    477 
    478   InitializeDatabase();
    479   EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1));
    480 
    481   metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1);
    482   metadata_store()->AddIncrementalSyncOrigin(kOrigin2, kResourceId2);
    483   metadata_store()->AddIncrementalSyncOrigin(kOrigin3, kResourceId3);
    484   DisableOrigin(kOrigin3);
    485   EXPECT_EQ(2u, metadata_store()->incremental_sync_origins().size());
    486   EXPECT_EQ(1u, metadata_store()->disabled_origins().size());
    487 
    488   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
    489       CreateSyncableFileSystemURL(kOrigin1, base::FilePath(FPL("guf"))),
    490       CreateMetadata("file:foo", "spam", false, false,
    491                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
    492   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
    493       CreateSyncableFileSystemURL(kOrigin2, base::FilePath(FPL("mof"))),
    494       CreateMetadata("file:bar", "ham", false, false,
    495                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
    496   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
    497       CreateSyncableFileSystemURL(kOrigin3, base::FilePath(FPL("waf"))),
    498       CreateMetadata("folder:baz", "egg", false, false,
    499                      DriveMetadata_ResourceType_RESOURCE_TYPE_FOLDER)));
    500 
    501   EXPECT_EQ(SYNC_STATUS_OK, RemoveOrigin(kOrigin2));
    502   EXPECT_EQ(SYNC_STATUS_OK, RemoveOrigin(kOrigin3));
    503 
    504   DropDatabase();
    505   InitializeDatabase();
    506 
    507   // kOrigin1 should be the only one left.
    508   EXPECT_EQ(1u, metadata_store()->incremental_sync_origins().size());
    509   EXPECT_EQ(0u, metadata_store()->disabled_origins().size());
    510   EXPECT_TRUE(metadata_store()->IsIncrementalSyncOrigin(kOrigin1));
    511   EXPECT_EQ(1u, metadata_map().size());
    512 
    513   DriveMetadataStore::MetadataMap::const_iterator found =
    514       metadata_map().find(kOrigin1);
    515   EXPECT_TRUE(found != metadata_map().end() && found->second.size() == 1u);
    516 
    517   VerifyReverseMap();
    518 }
    519 
    520 void DriveMetadataStoreTest::GetResourceIdForOrigin_Body() {
    521   const GURL kOrigin1("chrome-extension://example1");
    522   const GURL kOrigin2("chrome-extension://example2");
    523   const GURL kOrigin3("chrome-extension://example3");
    524   const std::string kResourceId1(CreateResourceId("folder:hogera"));
    525   const std::string kResourceId2(CreateResourceId("folder:fugaga"));
    526   const std::string kResourceId3(CreateResourceId("folder:piyopiyo"));
    527 
    528   InitializeDatabase();
    529   EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1));
    530   metadata_store()->SetSyncRootDirectory(CreateResourceId("folder:root"));
    531 
    532   metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1);
    533   metadata_store()->AddIncrementalSyncOrigin(kOrigin2, kResourceId2);
    534   metadata_store()->AddIncrementalSyncOrigin(kOrigin3, kResourceId3);
    535   DisableOrigin(kOrigin3);
    536 
    537   EXPECT_EQ(kResourceId1, metadata_store()->GetResourceIdForOrigin(kOrigin1));
    538   EXPECT_EQ(kResourceId2, metadata_store()->GetResourceIdForOrigin(kOrigin2));
    539   EXPECT_EQ(kResourceId3, metadata_store()->GetResourceIdForOrigin(kOrigin3));
    540 
    541   DropDatabase();
    542   InitializeDatabase();
    543 
    544   EXPECT_EQ(kResourceId1, metadata_store()->GetResourceIdForOrigin(kOrigin1));
    545   EXPECT_EQ(kResourceId2, metadata_store()->GetResourceIdForOrigin(kOrigin2));
    546   EXPECT_EQ(kResourceId3, metadata_store()->GetResourceIdForOrigin(kOrigin3));
    547 
    548   // Resetting the root directory resource ID to empty makes any
    549   // GetResourceIdForOrigin return an empty resource ID too, regardless of
    550   // whether they are known origin or not.
    551   metadata_store()->SetSyncRootDirectory(std::string());
    552   EXPECT_TRUE(metadata_store()->GetResourceIdForOrigin(kOrigin1).empty());
    553   EXPECT_TRUE(metadata_store()->GetResourceIdForOrigin(kOrigin2).empty());
    554   EXPECT_TRUE(metadata_store()->GetResourceIdForOrigin(kOrigin3).empty());
    555 
    556   // Make sure they're still known origins.
    557   EXPECT_TRUE(metadata_store()->IsKnownOrigin(kOrigin1));
    558   EXPECT_TRUE(metadata_store()->IsKnownOrigin(kOrigin2));
    559   EXPECT_TRUE(metadata_store()->IsKnownOrigin(kOrigin3));
    560 
    561   VerifyReverseMap();
    562 }
    563 
    564 void DriveMetadataStoreTest::ResetOriginRootDirectory_Body() {
    565   const GURL kOrigin1("chrome-extension://example1");
    566   const std::string kResourceId1(CreateResourceId("folder:hoge"));
    567   const std::string kResourceId2(CreateResourceId("folder:fuga"));
    568 
    569   InitializeDatabase();
    570   EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1));
    571 
    572   metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1);
    573   VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1);
    574   VerifyReverseMap();
    575 
    576   metadata_store()->SetOriginRootDirectory(kOrigin1, kResourceId2);
    577   VerifyIncrementalSyncOrigin(kOrigin1, kResourceId2);
    578   VerifyReverseMap();
    579 }
    580 
    581 void DriveMetadataStoreTest::GetFileMetadataMap_Body() {
    582   InitializeDatabase();
    583 
    584   // Save one file and folder to the origin.
    585   const base::FilePath file_path = base::FilePath(FPL("file_0"));
    586   const base::FilePath folder_path = base::FilePath(FPL("folder_0"));
    587 
    588   const GURL origin = GURL("chrome-extension://app_a");
    589   const fileapi::FileSystemURL url_0 = CreateSyncableFileSystemURL(
    590       origin, file_path);
    591   const fileapi::FileSystemURL url_1 = CreateSyncableFileSystemURL(
    592       origin, folder_path);
    593 
    594   // Insert DrivaMetadata objects.
    595   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
    596       url_0,
    597       CreateMetadata("file:0", "1", false, false,
    598                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
    599   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
    600       url_1,
    601       CreateMetadata("folder:0", "2", false, true,
    602                      DriveMetadata_ResourceType_RESOURCE_TYPE_FOLDER)));
    603 
    604   // Check that DriveMetadata objects get mapped back to generalized
    605   // FileMetadata objects.
    606   scoped_ptr<base::ListValue> files = metadata_store()->DumpFiles(origin);
    607   ASSERT_EQ(2u, files->GetSize());
    608 
    609   base::DictionaryValue* file = NULL;
    610   std::string str;
    611 
    612   ASSERT_TRUE(files->GetDictionary(0, &file));
    613   EXPECT_TRUE(file->GetString("title", &str) && str == "file_0");
    614   EXPECT_TRUE(file->GetString("type", &str) && str == "file");
    615   EXPECT_TRUE(file->HasKey("details"));
    616 
    617   ASSERT_TRUE(files->GetDictionary(1, &file));
    618   EXPECT_TRUE(file->GetString("title", &str) && str == "folder_0");
    619   EXPECT_TRUE(file->GetString("type", &str) && str == "folder");
    620   EXPECT_TRUE(file->HasKey("details"));
    621 }
    622 
    623 TEST_F(DriveMetadataStoreTest, Initialization) {
    624   ASSERT_FALSE(IsDriveAPIDisabled());
    625   InitializeDatabase();
    626 }
    627 
    628 TEST_F(DriveMetadataStoreTest, Initialization_WAPI) {
    629   SetDisableDriveAPI(true);
    630   InitializeDatabase();
    631 }
    632 
    633 TEST_F(DriveMetadataStoreTest, ReadWrite) {
    634   ASSERT_FALSE(IsDriveAPIDisabled());
    635   ReadWrite_Body();
    636 }
    637 
    638 TEST_F(DriveMetadataStoreTest, ReadWrite_WAPI) {
    639   SetDisableDriveAPI(true);
    640   ReadWrite_Body();
    641 }
    642 
    643 TEST_F(DriveMetadataStoreTest, GetConflictURLs) {
    644   ASSERT_FALSE(IsDriveAPIDisabled());
    645   GetConflictURLs_Body();
    646 }
    647 
    648 TEST_F(DriveMetadataStoreTest, GetConflictURLs_WAPI) {
    649   SetDisableDriveAPI(true);
    650   GetConflictURLs_Body();
    651 }
    652 
    653 TEST_F(DriveMetadataStoreTest, GetToBeFetchedFiles) {
    654   ASSERT_FALSE(IsDriveAPIDisabled());
    655   GetToBeFetchedFiles_Body();
    656 }
    657 
    658 TEST_F(DriveMetadataStoreTest, GetToBeFetchedFiles_WAPI) {
    659   SetDisableDriveAPI(true);
    660   GetToBeFetchedFiles_Body();
    661 }
    662 
    663 TEST_F(DriveMetadataStoreTest, StoreSyncRootDirectory) {
    664   ASSERT_FALSE(IsDriveAPIDisabled());
    665   StoreSyncRootDirectory_Body();
    666 }
    667 
    668 TEST_F(DriveMetadataStoreTest, StoreSyncRootDirectory_WAPI) {
    669   SetDisableDriveAPI(true);
    670   StoreSyncRootDirectory_Body();
    671 }
    672 
    673 TEST_F(DriveMetadataStoreTest, StoreSyncOrigin) {
    674   ASSERT_FALSE(IsDriveAPIDisabled());
    675   StoreSyncOrigin_Body();
    676 }
    677 
    678 TEST_F(DriveMetadataStoreTest, StoreSyncOrigin_WAPI) {
    679   SetDisableDriveAPI(true);
    680   StoreSyncOrigin_Body();
    681 }
    682 
    683 TEST_F(DriveMetadataStoreTest, DisableOrigin) {
    684   ASSERT_FALSE(IsDriveAPIDisabled());
    685   DisableOrigin_Body();
    686 }
    687 
    688 TEST_F(DriveMetadataStoreTest, DisableOrigin_WAPI) {
    689   SetDisableDriveAPI(true);
    690   DisableOrigin_Body();
    691 }
    692 
    693 TEST_F(DriveMetadataStoreTest, RemoveOrigin) {
    694   ASSERT_FALSE(IsDriveAPIDisabled());
    695   RemoveOrigin_Body();
    696 }
    697 
    698 TEST_F(DriveMetadataStoreTest, RemoveOrigin_WAPI) {
    699   SetDisableDriveAPI(true);
    700   RemoveOrigin_Body();
    701 }
    702 
    703 TEST_F(DriveMetadataStoreTest, GetResourceIdForOrigin) {
    704   ASSERT_FALSE(IsDriveAPIDisabled());
    705   GetResourceIdForOrigin_Body();
    706 }
    707 
    708 TEST_F(DriveMetadataStoreTest, GetResourceIdForOrigin_WAPI) {
    709   SetDisableDriveAPI(true);
    710   GetResourceIdForOrigin_Body();
    711 }
    712 
    713 TEST_F(DriveMetadataStoreTest, ResetOriginRootDirectory) {
    714   ASSERT_FALSE(IsDriveAPIDisabled());
    715   ResetOriginRootDirectory_Body();
    716 }
    717 
    718 TEST_F(DriveMetadataStoreTest, ResetOriginRootDirectory_WAPI) {
    719   SetDisableDriveAPI(true);
    720   ResetOriginRootDirectory_Body();
    721 }
    722 
    723 TEST_F(DriveMetadataStoreTest, GetFileMetadataMap) {
    724   ASSERT_FALSE(IsDriveAPIDisabled());
    725   GetFileMetadataMap_Body();
    726 }
    727 
    728 TEST_F(DriveMetadataStoreTest, GetFileMetadataMap_WAPI) {
    729   SetDisableDriveAPI(true);
    730   GetFileMetadataMap_Body();
    731 }
    732 
    733 }  // namespace sync_file_system
    734