Remove calls to IsRunningSequenceOnCurrentThread() from dom_storage_task_runner.cc

content/browser/dom_storage/dom_storage_area.cc

 // Copyright 2013 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 "content/browser/dom_storage/dom_storage_area.h"
 
 #include <inttypes.h>
 
 #include <algorithm>
 #include <cctype>  // for std::isalnum
@@ skipping 328 matching lines @@
     return;
 
   bool success = task_runner_->PostShutdownBlockingTask(
       FROM_HERE,
       DOMStorageTaskRunner::COMMIT_SEQUENCE,
       base::Bind(&DOMStorageArea::ShutdownInCommitSequence, this));
   DCHECK(success);
 }
 
 void DOMStorageArea::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd) {
-  DCHECK(task_runner_->IsRunningOnPrimarySequence());
+  task_runner_->AssertIsRunningOnPrimarySequence();
   if (!is_initial_import_done_)
     return;
 
   // Limit the url length to 50 and strip special characters.
   std::string url = origin_.spec().substr(0, 50);
   for (size_t index = 0; index < url.size(); ++index) {
     if (!std::isalnum(url[index]))
       url[index] = '_';
   }
   std::string name =
@@ skipping 68 matching lines @@
   if (!commit_batch_) {
     commit_batch_.reset(new CommitBatch());
     BrowserThread::PostAfterStartupTask(
         FROM_HERE, task_runner_,
         base::Bind(&DOMStorageArea::StartCommitTimer, this));
   }
   return commit_batch_.get();
 }
 
 void DOMStorageArea::PopulateCommitBatchValues() {
-  DCHECK(task_runner_->IsRunningOnPrimarySequence());
+  task_runner_->AssertIsRunningOnPrimarySequence();
   for (auto& key_value : commit_batch_->changed_values)
     key_value.second = map_->GetItem(key_value.first);
 }
 
 void DOMStorageArea::StartCommitTimer() {
   if (is_shutdown_ || !commit_batch_)
     return;
 
   // Start a timer to commit any changes that accrue in the batch, but only if
   // no commits are currently in flight. In that case the timer will be
@@ skipping 36 matching lines @@
     return;
 
   DCHECK(backing_.get());
 
   PopulateCommitBatchValues();
   commit_rate_limiter_.add_samples(1);
   data_rate_limiter_.add_samples(commit_batch_->GetDataSize());
 
   // This method executes on the primary sequence, we schedule
   // a task for immediate execution on the commit sequence.
-  DCHECK(task_runner_->IsRunningOnPrimarySequence());
+  task_runner_->AssertIsRunningOnPrimarySequence();
   bool success = task_runner_->PostShutdownBlockingTask(
       FROM_HERE,
       DOMStorageTaskRunner::COMMIT_SEQUENCE,
       base::Bind(&DOMStorageArea::CommitChanges, this,
                  base::Owned(commit_batch_.release())));
   ++commit_batches_in_flight_;
   DCHECK(success);
 }
 
 void DOMStorageArea::CommitChanges(const CommitBatch* commit_batch) {
   // This method executes on the commit sequence.
-  DCHECK(task_runner_->IsRunningOnCommitSequence());
+  task_runner_->AssertIsRunningOnCommitSequence();
   backing_->CommitChanges(commit_batch->clear_all_first,
                           commit_batch->changed_values);
   // TODO(michaeln): what if CommitChanges returns false (e.g., we're trying to
   // commit to a DB which is in an inconsistent state?)
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DOMStorageArea::OnCommitComplete, this));
 }
 
 void DOMStorageArea::OnCommitComplete() {
   // We're back on the primary sequence in this method.
-  DCHECK(task_runner_->IsRunningOnPrimarySequence());
+  task_runner_->AssertIsRunningOnPrimarySequence();
   --commit_batches_in_flight_;
   if (is_shutdown_)
     return;
   if (commit_batch_.get() && !commit_batches_in_flight_) {
     // More changes have accrued, restart the timer.
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&DOMStorageArea::OnCommitTimer, this),
         ComputeCommitDelay());
   }
 }
 
 void DOMStorageArea::ShutdownInCommitSequence() {
   // This method executes on the commit sequence.
-  DCHECK(task_runner_->IsRunningOnCommitSequence());
+  task_runner_->AssertIsRunningOnCommitSequence();
   DCHECK(backing_.get());
   if (commit_batch_) {
     // Commit any changes that accrued prior to the timer firing.
     bool success = backing_->CommitChanges(
         commit_batch_->clear_all_first,
         commit_batch_->changed_values);
     DCHECK(success);
   }
   commit_batch_.reset();
   backing_.reset();
   session_storage_backing_ = NULL;
 }
 
 }  // namespace content