Revert of Browser tests for using the new SafeBrowsing protocol (v4)

components/safe_browsing_db/v4_database.cc

 // Copyright 2016 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 <memory>
 
 #include "base/callback.h"
 #include "base/debug/leak_annotations.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/safe_browsing_db/v4_database.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 using base::TimeTicks;
 
 namespace safe_browsing {
 
 namespace {
 
 const char kV4DatabaseSizeMetric[] = "SafeBrowsing.V4Database.Size";
 
 }  // namespace
 
 // static
-std::unique_ptr<V4DatabaseFactory> V4Database::db_factory_;
-
-// static
-std::unique_ptr<V4StoreFactory> V4Database::store_factory_;
-
-std::unique_ptr<V4Database> V4DatabaseFactory::Create(
-    const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
-    std::unique_ptr<StoreMap> store_map) {
-  // Not using MakeUnique since the constructor of V4Database is protected.
-  return std::unique_ptr<V4Database>(
-      new V4Database(db_task_runner, std::move(store_map)));
-}
+V4StoreFactory* V4Database::factory_ = NULL;
 
 // static
 void V4Database::Create(
     const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
     const base::FilePath& base_path,
     const ListInfos& list_infos,
     NewDatabaseReadyCallback new_db_callback) {
   DCHECK(base_path.IsAbsolute());
   DCHECK(!list_infos.empty());
 
   const scoped_refptr<base::SingleThreadTaskRunner> callback_task_runner =
       base::ThreadTaskRunnerHandle::Get();
   db_task_runner->PostTask(
       FROM_HERE, base::Bind(&V4Database::CreateOnTaskRunner, db_task_runner,
                             base_path, list_infos, callback_task_runner,
                             new_db_callback, TimeTicks::Now()));
 }
 
 // static
 void V4Database::CreateOnTaskRunner(
     const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
     const base::FilePath& base_path,
     const ListInfos& list_infos,
     const scoped_refptr<base::SingleThreadTaskRunner>& callback_task_runner,
     NewDatabaseReadyCallback new_db_callback,
     const TimeTicks create_start_time) {
   DCHECK(db_task_runner->RunsTasksOnCurrentThread());
 
-  if (!store_factory_) {
-    store_factory_.reset(new V4StoreFactory());
+  if (!factory_) {
+    factory_ = new V4StoreFactory();
+    ANNOTATE_LEAKING_OBJECT_PTR(factory_);
   }
 
   if (!base::CreateDirectory(base_path)) {
     NOTREACHED();
   }
 
   std::unique_ptr<StoreMap> store_map = base::MakeUnique<StoreMap>();
   for (const auto& it : list_infos) {
     if (!it.fetch_updates()) {
       // This list doesn't need to be fetched or stored on disk.
       continue;
     }
 
     const base::FilePath store_path = base_path.AppendASCII(it.filename());
     (*store_map)[it.list_id()].reset(
-        store_factory_->CreateV4Store(db_task_runner, store_path));
-  }
-
-  if (!db_factory_) {
-    db_factory_.reset(new V4DatabaseFactory());
+        factory_->CreateV4Store(db_task_runner, store_path));
   }
   std::unique_ptr<V4Database> v4_database(
-      db_factory_->Create(db_task_runner, std::move(store_map)));
+      new V4Database(db_task_runner, std::move(store_map)));
 
   // Database is done loading, pass it to the new_db_callback on the caller's
   // thread. This would unblock resource loads.
   callback_task_runner->PostTask(
       FROM_HERE, base::Bind(new_db_callback, base::Passed(&v4_database)));
 
   UMA_HISTOGRAM_TIMES("SafeBrowsing.V4DatabaseOpen.Time",
                       TimeTicks::Now() - create_start_time);
 }
 
 V4Database::V4Database(
     const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
     std::unique_ptr<StoreMap> store_map)
-    : store_map_(std::move(store_map)),
-      db_task_runner_(db_task_runner),
+    : db_task_runner_(db_task_runner),
+      store_map_(std::move(store_map)),
       pending_store_updates_(0),
       weak_factory_on_io_(this) {
   DCHECK(db_task_runner->RunsTasksOnCurrentThread());
 }
 
 // static
 void V4Database::Destroy(std::unique_ptr<V4Database> v4_database) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   V4Database* v4_database_raw = v4_database.release();
   if (v4_database_raw) {
@@ skipping 158 matching lines @@
       filename_(filename),
       list_id_(list_id),
       sb_threat_type_(sb_threat_type) {
   DCHECK(!fetch_updates_ || !filename_.empty());
   DCHECK_NE(SB_THREAT_TYPE_SAFE, sb_threat_type_);
 }
 
 ListInfo::~ListInfo() {}
 
 }  // namespace safe_browsing