Move creation of BrowserContext objects that live in content to content, instead of depending on th…

chrome/browser/browsing_data_file_system_helper_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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/platform_file.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browsing_data_file_system_helper.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/test/test_browser_thread.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 
+using content::BrowserContext;
 using content::BrowserThread;
 
 namespace {
 
 // Shorter names for fileapi::* constants.
 const fileapi::FileSystemType kTemporary = fileapi::kFileSystemTypeTemporary;
 const fileapi::FileSystemType kPersistent = fileapi::kFileSystemTypePersistent;
 
 // We'll use these three distinct origins for testing, both as strings and as
 // GURLs in appropriate contexts.
@@ skipping 16 matching lines @@
 // The FileSystem APIs are all asynchronous; this testing class wraps up the
 // boilerplate code necessary to deal with waiting for responses. In a nutshell,
 // any async call whose response we want to test ought to be followed by a call
 // to BlockUntilNotified(), which will (shockingly!) block until Notify() is
 // called. For this to work, you'll need to ensure that each async call is
 // implemented as a class method that that calls Notify() at an appropriate
 // point.
 class BrowsingDataFileSystemHelperTest : public testing::Test {
  public:
   BrowsingDataFileSystemHelperTest()
-      : helper_(BrowsingDataFileSystemHelper::Create(&profile_)),
-        canned_helper_(new CannedBrowsingDataFileSystemHelper(&profile_)),
-        ui_thread_(BrowserThread::UI, &message_loop_),
+      : ui_thread_(BrowserThread::UI, &message_loop_),
+        db_thread_(BrowserThread::DB, &message_loop_),
+        webkit_thread_(BrowserThread::WEBKIT_DEPRECATED, &message_loop_),
         file_thread_(BrowserThread::FILE, &message_loop_),
+        file_user_blocking_thread_(
+            BrowserThread::FILE_USER_BLOCKING, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_) {
+    profile_.reset(new TestingProfile());
+    helper_ = BrowsingDataFileSystemHelper::Create(profile_.get());
+    canned_helper_ = new CannedBrowsingDataFileSystemHelper(profile_.get());
   }
-  virtual ~BrowsingDataFileSystemHelperTest() {}
+  virtual ~BrowsingDataFileSystemHelperTest() {
+    // Avoid memory leaks.
+    profile_.reset();
+    message_loop_.RunAllPending();
+  }
 
   TestingProfile* GetProfile() {
-    return &profile_;
+    return profile_.get();
   }
 
   // Blocks on the current MessageLoop until Notify() is called.
   void BlockUntilNotified() {
     MessageLoop::current()->Run();
   }
 
   // Unblocks the current MessageLoop. Should be called in response to some sort
   // of async activity in a callback method.
   void Notify() {
@@ skipping 47 matching lines @@
   void FetchCannedFileSystems() {
     canned_helper_->StartFetching(
         base::Bind(&BrowsingDataFileSystemHelperTest::CallbackStartFetching,
                    base::Unretained(this)));
     BlockUntilNotified();
   }
 
   // Sets up kOrigin1 with a temporary file system, kOrigin2 with a persistent
   // file system, and kOrigin3 with both.
   virtual void PopulateTestFileSystemData() {
-    sandbox_ = profile_.GetFileSystemContext()->sandbox_provider();
+    sandbox_ = BrowserContext::GetFileSystemContext(profile_.get())->
+        sandbox_provider();
 
     CreateDirectoryForOriginAndType(kOrigin1, kTemporary);
     CreateDirectoryForOriginAndType(kOrigin2, kPersistent);
     CreateDirectoryForOriginAndType(kOrigin3, kTemporary);
     CreateDirectoryForOriginAndType(kOrigin3, kPersistent);
 
     EXPECT_FALSE(FileSystemContainsOriginAndType(kOrigin1, kPersistent));
     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin1, kTemporary));
     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin2, kPersistent));
     EXPECT_FALSE(FileSystemContainsOriginAndType(kOrigin2, kTemporary));
@@ skipping 23 matching lines @@
 
   scoped_refptr<BrowsingDataFileSystemHelper> helper_;
   scoped_refptr<CannedBrowsingDataFileSystemHelper> canned_helper_;
 
  private:
   // message_loop_, as well as all the threads associated with it must be
   // defined before profile_ to prevent explosions. The threads also must be
   // defined in the order they're listed here. Oh how I love C++.
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
+  content::TestBrowserThread db_thread_;
+  content::TestBrowserThread webkit_thread_;
   content::TestBrowserThread file_thread_;
+  content::TestBrowserThread file_user_blocking_thread_;
   content::TestBrowserThread io_thread_;
-  TestingProfile profile_;
+  scoped_ptr<TestingProfile> profile_;
 
   // We don't own this pointer: don't delete it.
   fileapi::SandboxMountPointProvider* sandbox_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataFileSystemHelperTest);
 };
 
 // Verifies that the BrowsingDataFileSystemHelper correctly finds the test file
 // system data, and that each file system returned contains the expected data.
 TEST_F(BrowsingDataFileSystemHelperTest, FetchData) {
@@ skipping 87 matching lines @@
 
   info++;
   EXPECT_EQ(kOrigin2, info->origin);
   EXPECT_FALSE(info->has_persistent);
   EXPECT_TRUE(info->has_temporary);
   EXPECT_EQ(0, info->usage_persistent);
   EXPECT_EQ(100, info->usage_temporary);
 }
 
 }  // namespace