Migrate Extensions code to Task Scheduler API

extensions/browser/value_store/lazy_leveldb.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 "extensions/browser/value_store/lazy_leveldb.h"
 
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "base/threading/thread_restrictions.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/leveldatabase/env_chromium.h"
 #include "third_party/leveldatabase/src/include/leveldb/iterator.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
 using base::StringPiece;
 using content::BrowserThread;
 
 namespace {
 
@@ skipping 22 matching lines @@
 ValueStore::StatusCode LevelDbToValueStoreStatusCode(
     const leveldb::Status& status) {
   if (status.ok())
     return ValueStore::OK;
   if (status.IsCorruption())
     return ValueStore::CORRUPTION;
   return ValueStore::OTHER_ERROR;
 }
 
 leveldb::Status DeleteValue(leveldb::DB* db, const std::string& key) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   leveldb::WriteBatch batch;
   batch.Delete(key);
 
   return db->Write(leveldb::WriteOptions(), &batch);
 }
 
 }  // namespace
 
 LazyLevelDb::LazyLevelDb(const std::string& uma_client_name,
@@ skipping 15 matching lines @@
       "Extensions.Database.Database.Restore." + uma_client_name, 1,
       LEVELDB_DB_RESTORE_MAX, LEVELDB_DB_RESTORE_MAX + 1,
       base::Histogram::kUmaTargetedHistogramFlag);
   value_restore_histogram_ = base::LinearHistogram::FactoryGet(
       "Extensions.Database.Value.Restore." + uma_client_name, 1,
       LEVELDB_VALUE_RESTORE_MAX, LEVELDB_VALUE_RESTORE_MAX + 1,
       base::Histogram::kUmaTargetedHistogramFlag);
 }
 
 LazyLevelDb::~LazyLevelDb() {
-  if (db_ && !BrowserThread::CurrentlyOn(BrowserThread::FILE))
-    BrowserThread::DeleteSoon(BrowserThread::FILE, FROM_HERE, db_.release());
+  base::ThreadRestrictions::AssertIOAllowed();
 }
 
 ValueStore::Status LazyLevelDb::Read(const std::string& key,
                                      std::unique_ptr<base::Value>* value) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(value);
 
   std::string value_as_json;
   leveldb::Status s = db_->Get(read_options_, key, &value_as_json);
 
   if (s.IsNotFound()) {
     // Despite there being no value, it was still a success. Check this first
     // because ok() is false on IsNotFound.
     return ValueStore::Status();
   }
 
   if (!s.ok())
     return ToValueStoreError(s);
 
   std::unique_ptr<base::Value> val =
       base::JSONReader().ReadToValue(value_as_json);
   if (!val)
     return ValueStore::Status(ValueStore::CORRUPTION, FixCorruption(&key),
                               kInvalidJson);
 
   *value = std::move(val);
   return ValueStore::Status();
 }
 
 ValueStore::Status LazyLevelDb::Delete(const std::string& key) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   ValueStore::Status status = EnsureDbIsOpen();
   if (!status.ok())
     return status;
 
   return ToValueStoreError(DeleteValue(db_.get(), key));
 }
 
 ValueStore::BackingStoreRestoreStatus LazyLevelDb::LogRestoreStatus(
     ValueStore::BackingStoreRestoreStatus restore_status) const {
@@ skipping 15 matching lines @@
       break;
     case ValueStore::VALUE_RESTORE_DELETE_FAILURE:
       value_restore_histogram_->Add(LEVELDB_VALUE_RESTORE_DELETE_FAILURE);
       break;
   }
   return restore_status;
 }
 
 ValueStore::BackingStoreRestoreStatus LazyLevelDb::FixCorruption(
     const std::string* key) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
   leveldb::Status s;
   if (key && db_) {
     s = DeleteValue(db_.get(), *key);
     // Deleting involves writing to the log, so it's possible to have a
     // perfectly OK database but still have a delete fail.
     if (s.ok())
       return LogRestoreStatus(ValueStore::VALUE_RESTORE_DELETE_SUCCESS);
     else if (s.IsIOError())
       return LogRestoreStatus(ValueStore::VALUE_RESTORE_DELETE_FAILURE);
     // Any other kind of failure triggers a db repair.
@@ skipping 47 matching lines @@
     }
   }
 
   // Only log for the final and most extreme form of database restoration.
   LogRestoreStatus(restore_status);
 
   return restore_status;
 }
 
 ValueStore::Status LazyLevelDb::EnsureDbIsOpen() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   if (db_)
     return ValueStore::Status();
 
   if (db_unrecoverable_) {
     return ValueStore::Status(ValueStore::CORRUPTION,
                               ValueStore::DB_RESTORE_DELETE_FAILURE,
                               "Database corrupted");
   }
 
@@ skipping 25 matching lines @@
   std::string message = status.ToString();
   // The message may contain |db_path_|, which may be considered sensitive
   // data, and those strings are passed to the extension, so strip it out.
   base::ReplaceSubstringsAfterOffset(&message, 0u, db_path_.AsUTF8Unsafe(),
                                      "...");
 
   return ValueStore::Status(LevelDbToValueStoreStatusCode(status), message);
 }
 
 bool LazyLevelDb::DeleteDbFile() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
   db_.reset();  // release any lock on the directory
   if (!base::DeleteFile(db_path_, true /* recursive */)) {
     LOG(WARNING) << "Failed to delete leveldb database at " << db_path_.value();
     return false;
   }
   return true;
 }
 
 ValueStore::Status LazyLevelDb::CreateIterator(
     const leveldb::ReadOptions& read_options,
     std::unique_ptr<leveldb::Iterator>* iterator) {
   ValueStore::Status status = EnsureDbIsOpen();
   if (!status.ok())
     return status;
   *iterator = base::WrapUnique(db_->NewIterator(read_options));
   return ValueStore::Status();
 }