Kill DownloadManager::SearchDownloads, DownloadItem::MatchesQuery

chrome/browser/download/download_query_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 <string>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 115 matching lines @@
 // Syntactic sugar for an expression version of the switch-case statement.
 // Cf. Lisp's |case| form.
 #define SWITCH2(_index, _col1, _ret1, _default) \
   ((_index == (_col1)) ? _ret1 : _default)
 #define SWITCH3(_index, _col1, _ret1, _col2, _ret2, _default) \
   SWITCH2(_index, _col1, _ret1, SWITCH2(_index, _col2, _ret2, _default))
 #define SWITCH4(_index, _col1, _ret1, _col2, _ret2, _col3, _ret3, _default) \
   SWITCH3(_index, _col1, _ret1, _col2, _ret2, \
       SWITCH2(_index, _col3, _ret3, _default))
 
+TEST_F(DownloadQueryTest, DownloadQuery_QueryFilter) {
+  FilePath match_filename(FILE_PATH_LITERAL("query"));
+  FilePath fail_filename(FILE_PATH_LITERAL("fail"));
+  GURL fail_url("http://example.com/fail");
+  GURL match_url("http://query.com/query");
+  scoped_ptr<base::Value> query_str(base::Value::CreateStringValue("query"));
+  static const size_t kNumItems = 4;
+  CreateMocks(kNumItems);
+  for (size_t i = 0; i < kNumItems; ++i) {
+    if (i != 0)
+      EXPECT_CALL(mock(i), GetId()).WillOnce(Return(i));
+    EXPECT_CALL(mock(i), GetTargetFilePath())
+      .WillRepeatedly(ReturnRef((i & 1) ? match_filename : fail_filename));
+    EXPECT_CALL(mock(i), GetOriginalUrl())
+      .WillRepeatedly(ReturnRef((i & 2) ? match_url : fail_url));
+    EXPECT_CALL(mock(i), GetBrowserContext()).WillRepeatedly(Return(
+        static_cast<content::BrowserContext*>(NULL)));
+  }
+  query()->AddFilter(DownloadQuery::FILTER_QUERY, *query_str.get());
+  Search();
+  ASSERT_EQ(3U, results()->size());
+  EXPECT_EQ(1, results()->at(0)->GetId());
+  EXPECT_EQ(2, results()->at(1)->GetId());
+  EXPECT_EQ(3, results()->at(2)->GetId());
+
+  // TODO(phajdan.jr): Also test these strings:
+  //   "/\xe4\xbd\xa0\xe5\xa5\xbd\xe4\xbd\xa0\xe5\xa5\xbd",
+  //   L"/\x4f60\x597d\x4f60\x597d",
+  //   "/%E4%BD%A0%E5%A5%BD%E4%BD%A0%E5%A5%BD"
+}
+
 TEST_F(DownloadQueryTest, DownloadQueryAllFilters) {
   // Set up mocks such that only mock(0) matches all filters, and every other
   // mock fails a different filter (or two for GREATER/LESS filters).
-  static const size_t kNumItems = 19;
+  static const size_t kNumItems = 18;
   CreateMocks(kNumItems);
   FilePath refail_filename(FILE_PATH_LITERAL("z"));
   FilePath fail_filename(FILE_PATH_LITERAL("fail"));
   FilePath match_filename(FILE_PATH_LITERAL("match"));
   GURL refail_url("http://z.com/");
   GURL fail_url("http://example.com/fail");
   GURL match_url("http://example.com/match");
   // Picture a 2D matrix. The rows are MockDownloadItems and the columns are
   // filter types. Every cell contains a value that matches all filters, except
   // for the diagonal. Every item matches all the filters except one filter,
   // which it fails, except one item, which matches all the filters without
   // exception. Each mocked method is used to test (corresponds to) one or more
   // filter types (columns). For example, GetTotalBytes() is used to test
   // FILTER_TOTAL_BYTES_GREATER, FILTER_TOTAL_BYTES_LESS, and
   // FILTER_TOTAL_BYTES, so it uses 3 columns: it returns 1 for row (item) 11,
   // it returns 4 for row 12, 3 for 13, and it returns 2 for all other rows
   // (items).
   for (size_t i = 0; i < kNumItems; ++i) {
     EXPECT_CALL(mock(i), GetId()).WillRepeatedly(Return(i));
     EXPECT_CALL(mock(i), GetReceivedBytes()).WillRepeatedly(Return(SWITCH2(i,
         1, 2,
            1)));
     EXPECT_CALL(mock(i), GetSafetyState()).WillRepeatedly(Return(SWITCH2(i,
         2, DownloadItem::DANGEROUS,
            DownloadItem::DANGEROUS_BUT_VALIDATED)));
-    EXPECT_CALL(mock(i), GetFullPath()).WillRepeatedly(ReturnRef(SWITCH3(i,
+    EXPECT_CALL(mock(i), GetTargetFilePath())
+      .WillRepeatedly(ReturnRef(SWITCH3(i,
         3, refail_filename,
         4, fail_filename,
            match_filename)));
     EXPECT_CALL(mock(i), GetMimeType()).WillRepeatedly(Return(SWITCH2(i,
         5, "image",
            "text")));
     EXPECT_CALL(mock(i), IsPaused()).WillRepeatedly(Return(SWITCH2(i,
         6, false,
            true)));
-    EXPECT_CALL(mock(i), MatchesQuery(_)).WillRepeatedly(Return(SWITCH2(i,
-        7, false,
-           true)));
     EXPECT_CALL(mock(i), GetStartTime()).WillRepeatedly(Return(SWITCH4(i,
-        8,  base::Time::FromTimeT(1),
-        9,  base::Time::FromTimeT(4),
-        10, base::Time::FromTimeT(3),
-            base::Time::FromTimeT(2))));
+        7, base::Time::FromTimeT(1),
+        8, base::Time::FromTimeT(4),
+        9, base::Time::FromTimeT(3),
+           base::Time::FromTimeT(2))));
     EXPECT_CALL(mock(i), GetTotalBytes()).WillRepeatedly(Return(SWITCH4(i,
-        11, 1,
-        12, 4,
-        13, 3,
+        10, 1,
+        11, 4,
+        12, 3,
             2)));
     EXPECT_CALL(mock(i), GetOriginalUrl()).WillRepeatedly(ReturnRef(SWITCH3(i,
-        14, refail_url,
-        15, fail_url,
+        13, refail_url,
+        14, fail_url,
             match_url)));
+    // 15 is AddFilter(Bind(IdNotEqual, 15))
     EXPECT_CALL(mock(i), GetState()).WillRepeatedly(Return(SWITCH2(i,
-        17, DownloadItem::CANCELLED,
+        16, DownloadItem::CANCELLED,
             DownloadItem::IN_PROGRESS)));
     EXPECT_CALL(mock(i), GetDangerType()).WillRepeatedly(Return(SWITCH2(i,
-        18, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
+        17, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
             content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS)));
   }
   for (size_t i = 0; i < kNumItems; ++i) {
     switch (i) {
       case 0: break;
       case 1: AddFilter(DownloadQuery::FILTER_BYTES_RECEIVED, 1); break;
       case 2: AddFilter(DownloadQuery::FILTER_DANGER_ACCEPTED, true);
               break;
       case 3: AddFilter(DownloadQuery::FILTER_FILENAME_REGEX, "a"); break;
       case 4: AddFilter(DownloadQuery::FILTER_FILENAME,
                         match_filename.value().c_str()); break;
       case 5: AddFilter(DownloadQuery::FILTER_MIME, "text"); break;
       case 6: AddFilter(DownloadQuery::FILTER_PAUSED, true); break;
-      case 7: AddFilter(DownloadQuery::FILTER_QUERY, ""); break;
-      case 8: AddFilter(DownloadQuery::FILTER_STARTED_AFTER, 1000); break;
-      case 9: AddFilter(DownloadQuery::FILTER_STARTED_BEFORE, 4000);
+      case 7: AddFilter(DownloadQuery::FILTER_STARTED_AFTER, 1000); break;
+      case 8: AddFilter(DownloadQuery::FILTER_STARTED_BEFORE, 4000);
               break;
-      case 10: AddFilter(DownloadQuery::FILTER_START_TIME, 2000); break;
-      case 11: AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_GREATER, 1);
+      case 9: AddFilter(DownloadQuery::FILTER_START_TIME, 2000); break;
+      case 10: AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_GREATER, 1);
                break;
-      case 12: AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_LESS, 4);
+      case 11: AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_LESS, 4);
                break;
-      case 13: AddFilter(DownloadQuery::FILTER_TOTAL_BYTES, 2); break;
-      case 14: AddFilter(DownloadQuery::FILTER_URL_REGEX, "example");
+      case 12: AddFilter(DownloadQuery::FILTER_TOTAL_BYTES, 2); break;
+      case 13: AddFilter(DownloadQuery::FILTER_URL_REGEX, "example");
                break;
-      case 15: AddFilter(DownloadQuery::FILTER_URL,
+      case 14: AddFilter(DownloadQuery::FILTER_URL,
                          match_url.spec().c_str()); break;
-      case 16: CHECK(query()->AddFilter(base::Bind(&IdNotEqual, 16))); break;
-      case 17: query()->AddFilter(DownloadItem::IN_PROGRESS); break;
-      case 18: query()->AddFilter(content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
+      case 15: CHECK(query()->AddFilter(base::Bind(&IdNotEqual, 15))); break;
+      case 16: query()->AddFilter(DownloadItem::IN_PROGRESS); break;
+      case 17: query()->AddFilter(content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
         break;
       default: NOTREACHED(); break;
     }
     Search();
     ASSERT_EQ(kNumItems - i, results()->size())
       << "Failing filter: " << i;
     if (i > 0) {
       ASSERT_EQ(0, results()->at(0)->GetId())
         << "Failing filter: " << i;
       for (size_t j = 1; j < kNumItems - i; ++j) {
@@ skipping 39 matching lines @@
   query()->AddSorter(
       DownloadQuery::SORT_DANGER_ACCEPTED, DownloadQuery::DESCENDING);
   Search();
   EXPECT_EQ(DownloadItem::DANGEROUS_BUT_VALIDATED,
             results()->at(0)->GetSafetyState());
   EXPECT_EQ(DownloadItem::DANGEROUS, results()->at(1)->GetSafetyState());
 }
 
 TEST_F(DownloadQueryTest, DownloadQuerySortFilename) {
   CreateMocks(2);
-  FilePath a_filename(FILE_PATH_LITERAL("a"));
-  FilePath b_filename(FILE_PATH_LITERAL("b"));
-  EXPECT_CALL(mock(0), GetFullPath()).WillRepeatedly(ReturnRef(b_filename));
-  EXPECT_CALL(mock(1), GetFullPath()).WillRepeatedly(ReturnRef(a_filename));
+  FilePath a_path(FILE_PATH_LITERAL("a"));
+  FilePath b_path(FILE_PATH_LITERAL("b"));
+  EXPECT_CALL(mock(0), GetTargetFilePath()).WillRepeatedly(ReturnRef(b_path));
+  EXPECT_CALL(mock(1), GetTargetFilePath()).WillRepeatedly(ReturnRef(a_path));
   query()->AddSorter(
       DownloadQuery::SORT_FILENAME, DownloadQuery::ASCENDING);
   Search();
-  EXPECT_EQ(a_filename, results()->at(0)->GetFullPath());
-  EXPECT_EQ(b_filename, results()->at(1)->GetFullPath());
+  EXPECT_EQ(a_path, results()->at(0)->GetTargetFilePath());
+  EXPECT_EQ(b_path, results()->at(1)->GetTargetFilePath());
 }
 
 TEST_F(DownloadQueryTest, DownloadQuerySortMime) {
   CreateMocks(2);
   EXPECT_CALL(mock(0), GetMimeType()).WillRepeatedly(Return("a"));
   EXPECT_CALL(mock(1), GetMimeType()).WillRepeatedly(Return("b"));
   query()->AddSorter(
       DownloadQuery::SORT_MIME, DownloadQuery::DESCENDING);
   Search();
   EXPECT_EQ("b", results()->at(0)->GetMimeType());
@@ skipping 85 matching lines @@
   base::Time start = base::Time::Now();
   Search();
   base::Time end = base::Time::Now();
   double nanos = (end - start).InMillisecondsF() * 1000.0 * 1000.0;
   double nanos_per_item = nanos / static_cast<double>(kNumItems);
   double nanos_per_item_per_filter = nanos_per_item
     / static_cast<double>(kNumFilters);
   std::cout << "Search took " << nanos_per_item_per_filter
             << " nanoseconds per item per filter.\n";
 }