drive: Add ResourceMetadataStorage::Iterator::GetCacheEntry()

chrome/browser/chromeos/drive/search_metadata_unittest.cc

 // Copyright (c) 2013 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/chromeos/drive/search_metadata.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/i18n/string_search.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
@@ skipping 200 matching lines @@
       resource_metadata_;
   scoped_ptr<FileCache, test_util::DestroyHelperForTests> cache_;
 };
 
 TEST_F(SearchMetadataTest, SearchMetadata_ZeroMatches) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(base::MessageLoopProxy::current(),
                  resource_metadata_.get(),
-                 cache_.get(),
                  "NonExistent",
                  SEARCH_METADATA_ALL,
                  kDefaultAtMostNumMatches,
                  google_apis::test_util::CreateCopyResultCallback(
                      &error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(0U, result->size());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_RegularFile) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(base::MessageLoopProxy::current(),
                  resource_metadata_.get(),
-                 cache_.get(),
                  "SubDirectory File 1.txt",
                  SEARCH_METADATA_ALL,
                  kDefaultAtMostNumMatches,
                  google_apis::test_util::CreateCopyResultCallback(
                      &error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
   EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 // This test checks if |FindAndHighlightWrapper| does case-insensitive search.
 // Tricker test cases for |FindAndHighlightWrapper| can be found below.
 TEST_F(SearchMetadataTest, SearchMetadata_CaseInsensitiveSearch) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   // The query is all in lower case.
   SearchMetadata(base::MessageLoopProxy::current(),
                  resource_metadata_.get(),
-                 cache_.get(),
                  "subdirectory file 1.txt",
                  SEARCH_METADATA_ALL,
                  kDefaultAtMostNumMatches,
                  google_apis::test_util::CreateCopyResultCallback(
                      &error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
   EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_RegularFiles) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(base::MessageLoopProxy::current(),
                  resource_metadata_.get(),
-                 cache_.get(),
                  "SubDir",
                  SEARCH_METADATA_ALL,
                  kDefaultAtMostNumMatches,
                  google_apis::test_util::CreateCopyResultCallback(
                      &error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(2U, result->size());
 
   // The results should be sorted by the last accessed time in descending order.
   EXPECT_EQ(6, result->at(0).entry.file_info().last_accessed());
   EXPECT_EQ(2, result->at(1).entry.file_info().last_accessed());
 
   // All base names should contain "File".
   EXPECT_EQ("drive/root/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt",
             result->at(0).path.AsUTF8Unsafe());
   EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt",
             result->at(1).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_AtMostOneFile) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   // There are two files matching "SubDir" but only one file should be
   // returned.
   SearchMetadata(base::MessageLoopProxy::current(),
                  resource_metadata_.get(),
-                 cache_.get(),
                  "SubDir",
                  SEARCH_METADATA_ALL,
                  1,  // at_most_num_matches
                  google_apis::test_util::CreateCopyResultCallback(
                      &error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
   EXPECT_EQ("drive/root/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_Directory) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(base::MessageLoopProxy::current(),
                  resource_metadata_.get(),
-                 cache_.get(),
                  "Directory 1",
                  SEARCH_METADATA_ALL,
                  kDefaultAtMostNumMatches,
                  google_apis::test_util::CreateCopyResultCallback(
                      &error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
   EXPECT_EQ("drive/root/Directory 1", result->at(0).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_HostedDocument) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(base::MessageLoopProxy::current(),
                  resource_metadata_.get(),
-                 cache_.get(),
                  "Document",
                  SEARCH_METADATA_ALL,
                  kDefaultAtMostNumMatches,
                  google_apis::test_util::CreateCopyResultCallback(
                      &error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
 
   EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_ExcludeHostedDocument) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(base::MessageLoopProxy::current(),
                  resource_metadata_.get(),
-                 cache_.get(),
                  "Document",
                  SEARCH_METADATA_EXCLUDE_HOSTED_DOCUMENTS,
                  kDefaultAtMostNumMatches,
                  google_apis::test_util::CreateCopyResultCallback(
                      &error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(0U, result->size());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_SharedWithMe) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(base::MessageLoopProxy::current(),
                  resource_metadata_.get(),
-                 cache_.get(),
                  "",
                  SEARCH_METADATA_SHARED_WITH_ME,
                  kDefaultAtMostNumMatches,
                  google_apis::test_util::CreateCopyResultCallback(
                      &error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
   EXPECT_EQ("drive/root/Directory 1/Shared To The Account Owner.txt",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_FileAndDirectory) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(base::MessageLoopProxy::current(),
                  resource_metadata_.get(),
-                 cache_.get(),
                  "excludeDir-test",
                  SEARCH_METADATA_ALL,
                  kDefaultAtMostNumMatches,
                  google_apis::test_util::CreateCopyResultCallback(
                      &error, &result));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(2U, result->size());
 
   EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc",
             result->at(0).path.AsUTF8Unsafe());
   EXPECT_EQ("drive/root/Directory 2 excludeDir-test",
             result->at(1).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_ExcludeDirectory) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(base::MessageLoopProxy::current(),
                  resource_metadata_.get(),
-                 cache_.get(),
                  "excludeDir-test",
                  SEARCH_METADATA_EXCLUDE_DIRECTORIES,
                  kDefaultAtMostNumMatches,
                  google_apis::test_util::CreateCopyResultCallback(
                      &error, &result));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
 
   EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 // "drive", "drive/root", "drive/other" should be excluded.
 TEST_F(SearchMetadataTest, SearchMetadata_ExcludeSpecialDirectories) {
   const char* kQueries[] = { "drive", "root", "other" };
   for (size_t i = 0; i < arraysize(kQueries); ++i) {
     FileError error = FILE_ERROR_FAILED;
     scoped_ptr<MetadataSearchResultVector> result;
 
     const std::string query = kQueries[i];
     SearchMetadata(base::MessageLoopProxy::current(),
                    resource_metadata_.get(),
-                   cache_.get(),
                    query,
                    SEARCH_METADATA_ALL,
                    kDefaultAtMostNumMatches,
                    google_apis::test_util::CreateCopyResultCallback(
                        &error, &result));
 
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(FILE_ERROR_OK, error);
     ASSERT_TRUE(result);
     ASSERT_TRUE(result->empty()) << ": " << query << " should not match";
   }
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_Offline) {
   const std::vector<test_util::TestCacheResource> cache_resources =
       test_util::GetDefaultTestCacheResources();
   ASSERT_TRUE(test_util::PrepareTestCacheResources(cache_.get(),
                                                    cache_resources));
   {
     MetadataInfoGenerator generator("cache", kCacheEntriesLastAccessedTimeBase);
     AddEntriesToMetadataFromCache(cache_resources, &generator);
   }
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(base::MessageLoopProxy::current(),
                  resource_metadata_.get(),
-                 cache_.get(),
                  "",
                  SEARCH_METADATA_OFFLINE,
                  kDefaultAtMostNumMatches,
                  google_apis::test_util::CreateCopyResultCallback(
                      &error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_EQ(6U, result->size());
 
   // Newer entries are listed earlier. So, the results come in the reverse
@@ skipping 104 matching lines @@
 }
 
 TEST(SearchMetadataSimpleTest, FindAndHighlight_MoreMetaChars) {
   std::string highlighted_text;
   EXPECT_TRUE(FindAndHighlightWrapper("a&b&c&d", "b&c", &highlighted_text));
   EXPECT_EQ("a&amp;<b>b&amp;c</b>&amp;d", highlighted_text);
 }
 
 }  // namespace internal
 }  // namespace drive