Replace DCHECK(BrowserThread::CurrentlyOn) with DCHECK_CURRENTLY_ON in extensions.

chrome/browser/extensions/api/image_writer_private/operation.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 "chrome/browser/extensions/api/image_writer_private/operation.h"
 
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/threading/worker_pool.h"
 #include "chrome/browser/extensions/api/image_writer_private/error_messages.h"
@@ skipping 23 matching lines @@
 #else
       device_path_(device_path),
 #endif
       stage_(image_writer_api::STAGE_UNKNOWN),
       progress_(0) {
 }
 
 Operation::~Operation() {}
 
 void Operation::Cancel() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   stage_ = image_writer_api::STAGE_NONE;
 
   CleanUp();
 }
 
 void Operation::Abort() {
   Error(error::kAborted);
 }
 
@@ skipping 26 matching lines @@
   }
 
   AddCleanUpFunction(
       base::Bind(base::IgnoreResult(&base::ScopedTempDir::Delete),
                  base::Unretained(&temp_dir_)));
 
   StartImpl();
 }
 
 void Operation::Unzip(const base::Closure& continuation) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (IsCancelled()) {
     return;
   }
 
   if (image_path_.Extension() != FILE_PATH_LITERAL(".zip")) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, continuation);
     return;
   }
 
   SetStage(image_writer_api::STAGE_UNZIP);
@@ skipping 116 matching lines @@
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&OperationManager::OnProgress,
                  manager_,
                  extension_id_,
                  stage_,
                  progress_));
 }
 
 bool Operation::IsCancelled() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   return stage_ == image_writer_api::STAGE_NONE;
 }
 
 void Operation::AddCleanUpFunction(const base::Closure& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   cleanup_functions_.push_back(callback);
 }
 
 void Operation::CompleteAndContinue(const base::Closure& continuation) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   SetProgress(kProgressComplete);
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, continuation);
 }
 
 #if !defined(OS_CHROMEOS)
 void Operation::StartUtilityClient() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (!image_writer_client_) {
     image_writer_client_ = new ImageWriterUtilityClient();
     AddCleanUpFunction(base::Bind(&Operation::StopUtilityClient, this));
   }
 }
 
 void Operation::StopUtilityClient() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&ImageWriterUtilityClient::Shutdown, image_writer_client_));
 }
 
 void Operation::WriteImageProgress(int64 total_bytes, int64 curr_bytes) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (IsCancelled()) {
     return;
   }
 
   int progress = kProgressComplete * curr_bytes / total_bytes;
 
   if (progress > GetProgress()) {
     SetProgress(progress);
   }
 }
@@ skipping 82 matching lines @@
       // Skip closing the file.
       return;
     } else {
       // We didn't read the bytes we expected.
       Error(error::kHashReadError);
     }
   }
 }
 
 void Operation::OnUnzipFailure() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   Error(error::kUnzipGenericError);
 }
 
 void Operation::OnUnzipProgress(int64 total_bytes, int64 progress_bytes) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   int progress_percent = kProgressComplete * progress_bytes / total_bytes;
   SetProgress(progress_percent);
 }
 
 void Operation::CleanUp() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   for (std::vector<base::Closure>::iterator it = cleanup_functions_.begin();
        it != cleanup_functions_.end();
        ++it) {
     it->Run();
   }
   cleanup_functions_.clear();
 }
 
 }  // namespace image_writer
 }  // namespace extensions