Move some database tests next to the files they cover.

content/browser/database_quota_client_unittest.cc

Index: content/browser/database_quota_client_unittest.cc
diff --git a/content/browser/database_quota_client_unittest.cc b/content/browser/database_quota_client_unittest.cc
deleted file mode 100644
index 291ef2c73b637a8e2238a2459f9c14c05b04e48a..0000000000000000000000000000000000000000
--- a/content/browser/database_quota_client_unittest.cc
+++ /dev/null
@@ -1,283 +0,0 @@
-// Copyright 2014 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 <stdint.h>
-
-#include <map>
-
-#include "base/bind.h"
-#include "base/files/file_path.h"
-#include "base/location.h"
-#include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "net/base/completion_callback.h"
-#include "net/base/net_errors.h"
-#include "storage/browser/database/database_quota_client.h"
-#include "storage/browser/database/database_tracker.h"
-#include "storage/browser/database/database_util.h"
-#include "storage/common/database/database_identifier.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using storage::DatabaseQuotaClient;
-using storage::DatabaseTracker;
-using storage::OriginInfo;
-
-namespace content {
-
-// Declared to shorten the line lengths.
-static const storage::StorageType kTemp = storage::kStorageTypeTemporary;
-static const storage::StorageType kPerm = storage::kStorageTypePersistent;
-
-// Mock tracker class the mocks up those methods of the tracker
-// that are used by the QuotaClient.
-class MockDatabaseTracker : public DatabaseTracker {
- public:
-  MockDatabaseTracker()
-      : DatabaseTracker(base::FilePath(), false, NULL, NULL, NULL),
-        delete_called_count_(0),
-        async_delete_(false) {}
-
-  bool GetOriginInfo(const std::string& origin_identifier,
-                     OriginInfo* info) override {
-    std::map<GURL, MockOriginInfo>::const_iterator found =
-        mock_origin_infos_.find(
-            storage::GetOriginFromIdentifier(origin_identifier));
-    if (found == mock_origin_infos_.end())
-      return false;
-    *info = OriginInfo(found->second);
-    return true;
-  }
-
-  bool GetAllOriginIdentifiers(
-      std::vector<std::string>* origins_identifiers) override {
-    std::map<GURL, MockOriginInfo>::const_iterator iter;
-    for (iter = mock_origin_infos_.begin();
-         iter != mock_origin_infos_.end();
-         ++iter) {
-      origins_identifiers->push_back(iter->second.GetOriginIdentifier());
-    }
-    return true;
-  }
-
-  bool GetAllOriginsInfo(std::vector<OriginInfo>* origins_info) override {
-    std::map<GURL, MockOriginInfo>::const_iterator iter;
-    for (iter = mock_origin_infos_.begin();
-         iter != mock_origin_infos_.end();
-         ++iter) {
-      origins_info->push_back(OriginInfo(iter->second));
-    }
-    return true;
-  }
-
-  int DeleteDataForOrigin(const std::string& origin_identifier,
-                          const net::CompletionCallback& callback) override {
-    ++delete_called_count_;
-    if (async_delete()) {
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(&MockDatabaseTracker::AsyncDeleteDataForOrigin,
-                                this, callback));
-      return net::ERR_IO_PENDING;
-    }
-    return net::OK;
-  }
-
-  void AsyncDeleteDataForOrigin(const net::CompletionCallback& callback) {
-    callback.Run(net::OK);
-  }
-
-  void AddMockDatabase(const GURL& origin,  const char* name, int size) {
-    MockOriginInfo& info = mock_origin_infos_[origin];
-    info.set_origin(storage::GetIdentifierFromOrigin(origin));
-    info.AddMockDatabase(base::ASCIIToUTF16(name), size);
-  }
-
-  int delete_called_count() { return delete_called_count_; }
-  bool async_delete() { return async_delete_; }
-  void set_async_delete(bool async) { async_delete_ = async; }
-
- protected:
-  ~MockDatabaseTracker() override {}
-
- private:
-  class MockOriginInfo : public OriginInfo {
-   public:
-    void set_origin(const std::string& origin_identifier) {
-      origin_identifier_ = origin_identifier;
-    }
-
-    void AddMockDatabase(const base::string16& name, int size) {
-      EXPECT_TRUE(database_info_.find(name) == database_info_.end());
-      database_info_[name].first = size;
-      total_size_ += size;
-    }
-  };
-
-  int delete_called_count_;
-  bool async_delete_;
-  std::map<GURL, MockOriginInfo> mock_origin_infos_;
-};
-
-
-// Base class for our test fixtures.
-class DatabaseQuotaClientTest : public testing::Test {
- public:
-  const GURL kOriginA;
-  const GURL kOriginB;
-  const GURL kOriginOther;
-
-  DatabaseQuotaClientTest()
-      : kOriginA("http://host"),
-        kOriginB("http://host:8000"),
-        kOriginOther("http://other"),
-        usage_(0),
-        mock_tracker_(new MockDatabaseTracker),
-        weak_factory_(this) {
-  }
-
-  int64_t GetOriginUsage(storage::QuotaClient* client,
-                         const GURL& origin,
-                         storage::StorageType type) {
-    usage_ = 0;
-    client->GetOriginUsage(
-        origin, type,
-        base::Bind(&DatabaseQuotaClientTest::OnGetOriginUsageComplete,
-                   weak_factory_.GetWeakPtr()));
-    base::RunLoop().RunUntilIdle();
-    return usage_;
-  }
-
-  const std::set<GURL>& GetOriginsForType(storage::QuotaClient* client,
-                                          storage::StorageType type) {
-    origins_.clear();
-    client->GetOriginsForType(
-        type,
-        base::Bind(&DatabaseQuotaClientTest::OnGetOriginsComplete,
-                   weak_factory_.GetWeakPtr()));
-    base::RunLoop().RunUntilIdle();
-    return origins_;
-  }
-
-  const std::set<GURL>& GetOriginsForHost(storage::QuotaClient* client,
-                                          storage::StorageType type,
-                                          const std::string& host) {
-    origins_.clear();
-    client->GetOriginsForHost(
-        type, host,
-        base::Bind(&DatabaseQuotaClientTest::OnGetOriginsComplete,
-                   weak_factory_.GetWeakPtr()));
-    base::RunLoop().RunUntilIdle();
-    return origins_;
-  }
-
-  bool DeleteOriginData(storage::QuotaClient* client,
-                        storage::StorageType type,
-                        const GURL& origin) {
-    delete_status_ = storage::kQuotaStatusUnknown;
-    client->DeleteOriginData(
-        origin, type,
-        base::Bind(&DatabaseQuotaClientTest::OnDeleteOriginDataComplete,
-                   weak_factory_.GetWeakPtr()));
-    base::RunLoop().RunUntilIdle();
-    return delete_status_ == storage::kQuotaStatusOk;
-  }
-
-  MockDatabaseTracker* mock_tracker() { return mock_tracker_.get(); }
-
-
- private:
-  void OnGetOriginUsageComplete(int64_t usage) { usage_ = usage; }
-
-  void OnGetOriginsComplete(const std::set<GURL>& origins) {
-    origins_ = origins;
-  }
-
-  void OnDeleteOriginDataComplete(storage::QuotaStatusCode status) {
-    delete_status_ = status;
-  }
-
-  base::MessageLoop message_loop_;
-  int64_t usage_;
-  std::set<GURL> origins_;
-  storage::QuotaStatusCode delete_status_;
-  scoped_refptr<MockDatabaseTracker> mock_tracker_;
-  base::WeakPtrFactory<DatabaseQuotaClientTest> weak_factory_;
-};
-
-
-TEST_F(DatabaseQuotaClientTest, GetOriginUsage) {
-  DatabaseQuotaClient client(base::ThreadTaskRunnerHandle::Get().get(),
-                             mock_tracker());
-
-  EXPECT_EQ(0, GetOriginUsage(&client, kOriginA, kTemp));
-  EXPECT_EQ(0, GetOriginUsage(&client, kOriginA, kPerm));
-
-  mock_tracker()->AddMockDatabase(kOriginA, "fooDB", 1000);
-  EXPECT_EQ(1000, GetOriginUsage(&client, kOriginA, kTemp));
-  EXPECT_EQ(0, GetOriginUsage(&client, kOriginA, kPerm));
-
-  EXPECT_EQ(0, GetOriginUsage(&client, kOriginB, kPerm));
-  EXPECT_EQ(0, GetOriginUsage(&client, kOriginB, kTemp));
-}
-
-TEST_F(DatabaseQuotaClientTest, GetOriginsForHost) {
-  DatabaseQuotaClient client(base::ThreadTaskRunnerHandle::Get().get(),
-                             mock_tracker());
-
-  EXPECT_EQ(kOriginA.host(), kOriginB.host());
-  EXPECT_NE(kOriginA.host(), kOriginOther.host());
-
-  std::set<GURL> origins = GetOriginsForHost(&client, kTemp, kOriginA.host());
-  EXPECT_TRUE(origins.empty());
-
-  mock_tracker()->AddMockDatabase(kOriginA, "fooDB", 1000);
-  origins = GetOriginsForHost(&client, kTemp, kOriginA.host());
-  EXPECT_EQ(origins.size(), 1ul);
-  EXPECT_TRUE(origins.find(kOriginA) != origins.end());
-
-  mock_tracker()->AddMockDatabase(kOriginB, "barDB", 1000);
-  origins = GetOriginsForHost(&client, kTemp, kOriginA.host());
-  EXPECT_EQ(origins.size(), 2ul);
-  EXPECT_TRUE(origins.find(kOriginA) != origins.end());
-  EXPECT_TRUE(origins.find(kOriginB) != origins.end());
-
-  EXPECT_TRUE(GetOriginsForHost(&client, kPerm, kOriginA.host()).empty());
-  EXPECT_TRUE(GetOriginsForHost(&client, kTemp, kOriginOther.host()).empty());
-}
-
-TEST_F(DatabaseQuotaClientTest, GetOriginsForType) {
-  DatabaseQuotaClient client(base::ThreadTaskRunnerHandle::Get().get(),
-                             mock_tracker());
-
-  EXPECT_TRUE(GetOriginsForType(&client, kTemp).empty());
-  EXPECT_TRUE(GetOriginsForType(&client, kPerm).empty());
-
-  mock_tracker()->AddMockDatabase(kOriginA, "fooDB", 1000);
-  std::set<GURL> origins = GetOriginsForType(&client, kTemp);
-  EXPECT_EQ(origins.size(), 1ul);
-  EXPECT_TRUE(origins.find(kOriginA) != origins.end());
-
-  EXPECT_TRUE(GetOriginsForType(&client, kPerm).empty());
-}
-
-TEST_F(DatabaseQuotaClientTest, DeleteOriginData) {
-  DatabaseQuotaClient client(base::ThreadTaskRunnerHandle::Get().get(),
-                             mock_tracker());
-
-  // Perm deletions are short circuited in the Client and
-  // should not reach the DatabaseTracker.
-  EXPECT_TRUE(DeleteOriginData(&client, kPerm, kOriginA));
-  EXPECT_EQ(0, mock_tracker()->delete_called_count());
-
-  mock_tracker()->set_async_delete(false);
-  EXPECT_TRUE(DeleteOriginData(&client, kTemp, kOriginA));
-  EXPECT_EQ(1, mock_tracker()->delete_called_count());
-
-  mock_tracker()->set_async_delete(true);
-  EXPECT_TRUE(DeleteOriginData(&client, kTemp, kOriginA));
-  EXPECT_EQ(2, mock_tracker()->delete_called_count());
-}
-
-}  // namespace content