Only invoke WebKit methods in browsing data helpers on the WEBKIT thread.

chrome/browser/browsing_data_database_helper_browsertest.cc

 // Copyright (c) 2010 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 "base/file_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browsing_data_database_helper.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/test/in_process_browser_test.h"
 #include "chrome/test/testing_profile.h"
 #include "chrome/test/ui_test_utils.h"
 
+namespace {
 static const char kTestIdentifier1[] = "http_www.google.com_0";
 
 static const char kTestIdentifierExtension[] =
   "chrome-extension_behllobkkfkfnphdnhnkndlbkcpglgmj_0";
 
+class TestCompletionCallback {

[Bernhard Bauer, 2011/02/08 10:49:08]

Do you think it would be complicated to pull this callback out into a class
(template) you could use for all three browser tests?

+ public:
+  TestCompletionCallback()
+      : have_result_(false),
+        waiting_for_result_(false) {
+  }
+
+  const std::vector<BrowsingDataDatabaseHelper::DatabaseInfo>& result() {
+    WaitForResult();
+    return result_;
+  }
+
+  void callback(const std::vector<
+          BrowsingDataDatabaseHelper::DatabaseInfo>& info) {
+    have_result_ = true;
+    result_ = info;
+    if (waiting_for_result_)

[Bernhard Bauer, 2011/02/08 10:49:08]

I think this is unnecessary. |MessageLoop::Quit| will DCHECK that it's never
called outside of |MessageLoop::Run|, so we can be sure that |callback| isn't
either even if we unconditionally quit the MessageLoop here.

+      MessageLoop::current()->Quit();
+  }
+
+ private:
+  void WaitForResult() {
+    if (!have_result_) {

[Bernhard Bauer, 2011/02/08 10:49:08]

That doesn't make sense now ;-) You should DCHECK |have_result_| after
|WaitForResult| (or after |MessageLoop::Run|).

+      waiting_for_result_ = true;
+      MessageLoop::current()->Run();
+      waiting_for_result_ = false;
+    }
+  }
+
+  bool have_result_;
+  bool waiting_for_result_;
+  std::vector<BrowsingDataDatabaseHelper::DatabaseInfo> result_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestCompletionCallback);
+};
+}  // namespace
+
 class BrowsingDataDatabaseHelperTest : public InProcessBrowserTest {
  public:
   virtual void CreateDatabases() {
     webkit_database::DatabaseTracker* db_tracker =
         testing_profile_.GetDatabaseTracker();
     string16 db_name = ASCIIToUTF16("db");
     string16 description = ASCIIToUTF16("db_description");
     int64 size;
     int64 available;
     string16 identifier1(UTF8ToUTF16(kTestIdentifier1));
@@ skipping 46 matching lines @@
 IN_PROC_BROWSER_TEST_F(BrowsingDataDatabaseHelperTest, FetchData) {
   CreateDatabases();
   scoped_refptr<BrowsingDataDatabaseHelper> database_helper(
       new BrowsingDataDatabaseHelper(&testing_profile_));
   StopTestOnCallback stop_test_on_callback(database_helper);
   database_helper->StartFetching(
       NewCallback(&stop_test_on_callback, &StopTestOnCallback::Callback));
   // Blocks until StopTestOnCallback::Callback is notified.
   ui_test_utils::RunMessageLoop();
 }
+
+IN_PROC_BROWSER_TEST_F(BrowsingDataDatabaseHelperTest, CannedAddDatabase) {
+  const GURL origin1("http://host1:1/");
+  const GURL origin2("http://host2:1/");
+  const char origin_str1[] = "http_host1_1";
+  const char origin_str2[] = "http_host2_1";
+  const char db1[] = "db1";
+  const char db2[] = "db2";
+  const char db3[] = "db3";
+
+  scoped_refptr<CannedBrowsingDataDatabaseHelper> helper(
+      new CannedBrowsingDataDatabaseHelper(&testing_profile_));
+  helper->AddDatabase(origin1, db1, "");
+  helper->AddDatabase(origin1, db2, "");
+  helper->AddDatabase(origin2, db3, "");
+
+  TestCompletionCallback callback;
+  helper->StartFetching(
+      NewCallback(&callback, &TestCompletionCallback::callback));
+
+  std::vector<BrowsingDataDatabaseHelper::DatabaseInfo> result =
+      callback.result();
+
+  ASSERT_EQ(3u, result.size());
+  EXPECT_STREQ(origin_str1, result[0].origin_identifier.c_str());
+  EXPECT_STREQ(db1, result[0].database_name.c_str());
+  EXPECT_STREQ(origin_str1, result[1].origin_identifier.c_str());
+  EXPECT_STREQ(db2, result[1].database_name.c_str());
+  EXPECT_STREQ(origin_str2, result[2].origin_identifier.c_str());
+  EXPECT_STREQ(db3, result[2].database_name.c_str());
+}
+
+IN_PROC_BROWSER_TEST_F(BrowsingDataDatabaseHelperTest, CannedUnique) {
+  const GURL origin("http://host1:1/");
+  const char origin_str[] = "http_host1_1";
+  const char db[] = "db1";
+
+  scoped_refptr<CannedBrowsingDataDatabaseHelper> helper(
+      new CannedBrowsingDataDatabaseHelper(&testing_profile_));
+  helper->AddDatabase(origin, db, "");
+  helper->AddDatabase(origin, db, "");
+
+  TestCompletionCallback callback;
+  helper->StartFetching(
+      NewCallback(&callback, &TestCompletionCallback::callback));
+
+  std::vector<BrowsingDataDatabaseHelper::DatabaseInfo> result =
+      callback.result();
+
+  ASSERT_EQ(1u, result.size());
+  EXPECT_STREQ(origin_str, result[0].origin_identifier.c_str());
+  EXPECT_STREQ(db, result[0].database_name.c_str());
+}