Fix most of the downloads api in incognito profiles

chrome/browser/download/download_extension_test.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 <algorithm>
 
 #include "base/file_util.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/download/download_extension_api.h"
@@ skipping 41 matching lines @@
     const FilePath::CharType*   filename;
 
     // State for the download. Note that IN_PROGRESS downloads will be created
     // as CANCELLED.
     DownloadItem::DownloadState state;
 
     // Danger type for the download.
     content::DownloadDangerType danger_type;
   };
 
+  virtual Browser* current_browser() { return browser(); }
+
   // InProcessBrowserTest
   virtual void SetUpOnMainThread() OVERRIDE {
+    CHECK(current_browser());
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
     InProcessBrowserTest::SetUpOnMainThread();
-    ASSERT_TRUE(CreateAndSetDownloadsDirectory(browser()));
-    browser()->profile()->GetPrefs()->SetBoolean(prefs::kPromptForDownload,
-                                                 false);
+    CreateAndSetDownloadsDirectory();
+    current_browser()->profile()->GetPrefs()->SetBoolean(
+        prefs::kPromptForDownload, false);
     GetDownloadManager()->RemoveAllDownloads();
   }
 
-  DownloadManager* GetDownloadManager() {
+  virtual DownloadManager* GetDownloadManager() {
     DownloadService* download_service =
-        DownloadServiceFactory::GetForProfile(browser()->profile());
+        DownloadServiceFactory::GetForProfile(current_browser()->profile());
     return download_service->GetDownloadManager();
   }
 
   // Creates a set of history downloads based on the provided |history_info|
   // array. |count| is the number of elements in |history_info|. On success,
   // |items| will contain |count| DownloadItems in the order that they were
   // specified in |history_info|. Returns true on success and false otherwise.
   bool CreateHistoryDownloads(const HistoryDownloadInfo* history_info,
                               size_t count,
                               DownloadManager::DownloadVector* items) {
@@ skipping 30 matching lines @@
     return true;
   }
 
   void CreateSlowTestDownloads(
       size_t count, DownloadManager::DownloadVector* items) {
     for (size_t i = 0; i < count; ++i) {
       scoped_ptr<DownloadTestObserver> observer(
           CreateInProgressDownloadObserver(1));
       GURL slow_download_url(URLRequestSlowDownloadJob::kUnknownSizeUrl);
       ui_test_utils::NavigateToURLWithDisposition(
-          browser(), slow_download_url, CURRENT_TAB,
+          current_browser(), slow_download_url, CURRENT_TAB,
           ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
       observer->WaitForFinished();
       EXPECT_EQ(
           1u, observer->NumDownloadsSeenInState(DownloadItem::IN_PROGRESS));
       // We don't expect a select file dialog.
       CHECK(!observer->select_file_dialog_seen());
     }
     GetDownloadManager()->GetAllDownloads(FilePath(), items);
     CHECK_EQ(count, items->size());
   }
 
   DownloadItem* CreateSlowTestDownload() {
     scoped_ptr<DownloadTestObserver> observer(
         CreateInProgressDownloadObserver(1));
     GURL slow_download_url(URLRequestSlowDownloadJob::kUnknownSizeUrl);
     DownloadManager* manager = GetDownloadManager();
 
     EXPECT_EQ(0, manager->InProgressCount());
     if (manager->InProgressCount() != 0)
       return NULL;
 
     ui_test_utils::NavigateToURLWithDisposition(
-        browser(), slow_download_url, CURRENT_TAB,
+        current_browser(), slow_download_url, CURRENT_TAB,
         ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
     observer->WaitForFinished();
     EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::IN_PROGRESS));
     // We don't expect a select file dialog.
     if (observer->select_file_dialog_seen())
       return NULL;
 
     DownloadManager::DownloadVector items;
     manager->GetAllDownloads(FilePath(), &items);
 
     DownloadItem* new_item = NULL;
     for (DownloadManager::DownloadVector::iterator iter = items.begin();
          iter != items.end(); ++iter) {
       if ((*iter)->GetState() == DownloadItem::IN_PROGRESS) {
         // There should be only one IN_PROGRESS item.
         EXPECT_EQ(NULL, new_item);
         new_item = *iter;
       }
     }
     return new_item;
   }
 
   void FinishPendingSlowDownloads() {
     scoped_ptr<DownloadTestObserver> observer(
         CreateDownloadObserver(1));
     GURL finish_url(URLRequestSlowDownloadJob::kFinishDownloadUrl);
     ui_test_utils::NavigateToURLWithDisposition(
-        browser(), finish_url, NEW_FOREGROUND_TAB,
+        current_browser(), finish_url, NEW_FOREGROUND_TAB,
         ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
     observer->WaitForFinished();
     EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
   }
 
   DownloadTestObserver* CreateDownloadObserver(size_t download_count) {
     return new DownloadTestObserverTerminal(
         GetDownloadManager(), download_count, true,
         DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL);
   }
 
   DownloadTestObserver* CreateInProgressDownloadObserver(
       size_t download_count) {
     return new DownloadTestObserverInProgress(GetDownloadManager(),
                                               download_count,
                                               true);
   }
 
   bool RunFunction(UIThreadExtensionFunction* function,
                    const std::string& args) {
     // extension_function_test_utils::RunFunction() does not take
     // ownership of |function|.
     scoped_refptr<ExtensionFunction> function_owner(function);
     return extension_function_test_utils::RunFunction(
-        function, args, browser(), extension_function_test_utils::NONE);
+        function, args, current_browser(), extension_function_test_utils::NONE);
   }
 
   base::Value* RunFunctionAndReturnResult(UIThreadExtensionFunction* function,
                                           const std::string& args) {
     return extension_function_test_utils::RunFunctionAndReturnResult(
-        function, args, browser(), extension_function_test_utils::NONE);
+        function, args, current_browser(), extension_function_test_utils::NONE);
   }
 
   std::string RunFunctionAndReturnError(UIThreadExtensionFunction* function,
                                         const std::string& args) {
     return extension_function_test_utils::RunFunctionAndReturnError(
-        function, args, browser(), extension_function_test_utils::NONE);
+        function, args, current_browser(), extension_function_test_utils::NONE);
   }
 
   bool RunFunctionAndReturnString(UIThreadExtensionFunction* function,
                                   const std::string& args,
                                   std::string* result_string) {
     scoped_ptr<base::Value> result(RunFunctionAndReturnResult(function, args));
     EXPECT_TRUE(result.get());
     return result.get() && result->GetAsString(result_string);
   }
 
@@ skipping 22 matching lines @@
         &width, &height));
     EXPECT_EQ(expected_size, width);
     EXPECT_EQ(expected_size, height);
   }
 
   const FilePath& downloads_directory() {
     return downloads_directory_.path();
   }
 
  private:
-  bool CreateAndSetDownloadsDirectory(Browser* browser) {
-    if (!downloads_directory_.CreateUniqueTempDir())
-      return false;
-    browser->profile()->GetPrefs()->SetFilePath(
+  void CreateAndSetDownloadsDirectory() {
+    CHECK(downloads_directory_.CreateUniqueTempDir());

[Randy Smith (Not in Mondays), 2012/05/03 19:07:21]

So I don't like doing CHECKs in tests (comment applies throughout file) as if
the CHECK fails, the test core-dumps, which I believe is considered a more
serious failure than just failing (requires being disabled, or some such--it's a
bigger deal).  Is there a way to keep the functionality of just failing the test
if the things targeted by CHECKs fail?

[benjhayden, 2012/05/03 21:08:12]

Done.

+    current_browser()->profile()->GetPrefs()->SetFilePath(
         prefs::kDownloadDefaultDirectory,
         downloads_directory_.path());
-    return true;
   }
 
   ScopedTempDir downloads_directory_;
 };
 
+class DownloadExtensionTestIncognito : public DownloadExtensionTest {
+ public:
+  virtual Browser* current_browser() OVERRIDE { return current_browser_; }
+
+  virtual void SetUpOnMainThread() OVERRIDE {
+    GoOnTheRecord();
+    DownloadExtensionTest::SetUpOnMainThread();
+    incognito_browser_ = CreateIncognitoBrowser();
+    GoOffTheRecord();
+    CHECK(current_browser()->profile()->IsOffTheRecord());
+    GetDownloadManager()->RemoveAllDownloads();
+  }
+
+  void GoOnTheRecord() { current_browser_ = browser(); }
+  void GoOffTheRecord() { current_browser_ = incognito_browser_; }
+
+ private:
+  Browser* incognito_browser_;
+  Browser* current_browser_;
+};
+
 class MockIconExtractorImpl : public DownloadFileIconExtractor {
  public:
   MockIconExtractorImpl(const FilePath& path, IconLoader::IconSize icon_size,
                         const std::string& response)
     : expected_path_(path),
       expected_icon_size_(icon_size),
       response_(response) {
   }
   virtual ~MockIconExtractorImpl() {}
 
@@ skipping 498 matching lines @@
   ASSERT_TRUE(result.get());
   base::ListValue* result_list = NULL;
   ASSERT_TRUE(result->GetAsList(&result_list));
   ASSERT_EQ(1UL, result_list->GetSize());
   base::DictionaryValue* item_value = NULL;
   ASSERT_TRUE(result_list->GetDictionary(0, &item_value));
   FilePath::StringType item_name;
   ASSERT_TRUE(item_value->GetString("filename", &item_name));
   ASSERT_EQ(items[2]->GetFullPath().value(), item_name);
 }
+
+IN_PROC_BROWSER_TEST_F(DownloadExtensionTestIncognito,
+                       DownloadsApi_SearchIncognito) {
+  scoped_ptr<base::Value> result_value;
+  base::ListValue* result_list = NULL;
+  base::DictionaryValue* result_dict = NULL;
+  FilePath::StringType filename;
+  bool is_incognito = false;
+  std::string error;
+
+  // Set up one on-record item and one off-record item.
+
+  GoOnTheRecord();
+  DownloadItem* on_item = CreateSlowTestDownload();
+  ASSERT_TRUE(on_item);
+  ASSERT_FALSE(on_item->IsOtr());
+
+  GoOffTheRecord();
+  DownloadItem* off_item = CreateSlowTestDownload();
+  ASSERT_TRUE(off_item);
+  ASSERT_TRUE(off_item->IsOtr());
+  ASSERT_TRUE(on_item->GetFullPath() != off_item->GetFullPath());
+
+  // Extensions running in the incognito window should have access to the
+  // incognito items. The 'incognito:only' filter should filter out the
+  // on-record item.
+  result_value.reset(RunFunctionAndReturnResult(
+      new DownloadsSearchFunction(), "[{\"incognito\": \"only\"}]"));
+  ASSERT_TRUE(result_value.get());
+  ASSERT_TRUE(result_value->GetAsList(&result_list));
+  ASSERT_EQ(1UL, result_list->GetSize());
+  ASSERT_TRUE(result_list->GetDictionary(0, &result_dict));
+  ASSERT_TRUE(result_dict->GetString("filename", &filename));
+  EXPECT_TRUE(off_item->GetFullPath() == FilePath(filename));
+  ASSERT_TRUE(result_dict->GetBoolean("incognito", &is_incognito));
+  EXPECT_TRUE(is_incognito);
+
+  // Extensions running in the incognito window should *also* have access to the
+  // on-record items. The 'incognito:none' filter should filter out the
+  // off-record items.
+  result_value.reset(RunFunctionAndReturnResult(
+      new DownloadsSearchFunction(), "[{\"incognito\": \"none\"}]"));
+  ASSERT_TRUE(result_value.get());
+  ASSERT_TRUE(result_value->GetAsList(&result_list));
+  ASSERT_EQ(1UL, result_list->GetSize());
+  ASSERT_TRUE(result_list->GetDictionary(0, &result_dict));
+  ASSERT_TRUE(result_dict->GetString("filename", &filename));
+  EXPECT_TRUE(on_item->GetFullPath() == FilePath(filename));
+  ASSERT_TRUE(result_dict->GetBoolean("incognito", &is_incognito));
+  EXPECT_FALSE(is_incognito);
+
+  // Extensions running in the on-record window should *not* have access to the
+  // incognito items. Filtering out on-record items should leave zero items.
+  GoOnTheRecord();
+  result_value.reset(RunFunctionAndReturnResult(
+      new DownloadsSearchFunction(), "[{\"incognito\": \"only\"}]"));
+  ASSERT_TRUE(result_value.get());
+  ASSERT_TRUE(result_value->GetAsList(&result_list));
+  EXPECT_EQ(0UL, result_list->GetSize());
+
+  // Extensions running in the on-record window should still have access to the
+  // on-record items. The 'incognito:none' filter should have no effect in
+  // on-record windows.
+  result_value.reset(RunFunctionAndReturnResult(
+      new DownloadsSearchFunction(), "[{\"incognito\": \"none\"}]"));
+  ASSERT_TRUE(result_value.get());
+  ASSERT_TRUE(result_value->GetAsList(&result_list));
+  ASSERT_EQ(1UL, result_list->GetSize());
+  ASSERT_TRUE(result_list->GetDictionary(0, &result_dict));
+  ASSERT_TRUE(result_dict->GetString("filename", &filename));
+  EXPECT_TRUE(on_item->GetFullPath() == FilePath(filename));
+  ASSERT_TRUE(result_dict->GetBoolean("incognito", &is_incognito));
+  EXPECT_FALSE(is_incognito);
+
+  GoOffTheRecord();
+  // Do the pause/resume/cancel test for both the on- and off-items while in the
+  // off-record browser.
+  EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(),
+                          DownloadItemIdAsArgList(on_item)));
+  EXPECT_TRUE(on_item->IsPaused());
+  EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(),
+                          DownloadItemIdAsArgList(on_item)));
+  EXPECT_TRUE(on_item->IsPaused());
+  EXPECT_TRUE(RunFunction(new DownloadsResumeFunction(),
+                          DownloadItemIdAsArgList(on_item)));
+  EXPECT_FALSE(on_item->IsPaused());
+  EXPECT_TRUE(RunFunction(new DownloadsResumeFunction(),
+                          DownloadItemIdAsArgList(on_item)));
+  EXPECT_FALSE(on_item->IsPaused());
+  EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(),
+                          DownloadItemIdAsArgList(on_item)));
+  EXPECT_TRUE(on_item->IsPaused());
+  EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(),
+                          DownloadItemIdAsArgList(on_item)));
+  EXPECT_TRUE(on_item->IsCancelled());
+  EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(),
+                          DownloadItemIdAsArgList(on_item)));
+  EXPECT_TRUE(on_item->IsCancelled());
+  error = RunFunctionAndReturnError(
+      new DownloadsPauseFunction(), DownloadItemIdAsArgList(on_item));
+  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
+               error.c_str());
+  error = RunFunctionAndReturnError(
+      new DownloadsResumeFunction(), DownloadItemIdAsArgList(on_item));
+  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
+               error.c_str());
+  EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(),
+                          DownloadItemIdAsArgList(off_item)));
+  EXPECT_TRUE(off_item->IsPaused());
+  EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(),
+                          DownloadItemIdAsArgList(off_item)));
+  EXPECT_TRUE(off_item->IsPaused());
+  EXPECT_TRUE(RunFunction(new DownloadsResumeFunction(),
+                          DownloadItemIdAsArgList(off_item)));
+  EXPECT_FALSE(off_item->IsPaused());
+  EXPECT_TRUE(RunFunction(new DownloadsResumeFunction(),
+                          DownloadItemIdAsArgList(off_item)));
+  EXPECT_FALSE(off_item->IsPaused());
+  EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(),
+                          DownloadItemIdAsArgList(off_item)));
+  EXPECT_TRUE(off_item->IsPaused());
+  EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(),
+                          DownloadItemIdAsArgList(off_item)));
+  EXPECT_TRUE(off_item->IsCancelled());
+  EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(),
+                          DownloadItemIdAsArgList(off_item)));
+  EXPECT_TRUE(off_item->IsCancelled());
+  error = RunFunctionAndReturnError(
+      new DownloadsPauseFunction(), DownloadItemIdAsArgList(off_item));
+  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
+               error.c_str());
+  error = RunFunctionAndReturnError(
+      new DownloadsResumeFunction(), DownloadItemIdAsArgList(off_item));
+  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
+               error.c_str());
+}