favor DCHECK_CURRENTLY_ON for better logs in content/browser/[f-p]*

content/browser/media/webrtc_identity_store_backend.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/media/webrtc_identity_store_backend.h"
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string_util.h"
@@ skipping 111 matching lines @@
   void Close();
   void AddIdentity(const GURL& origin,
                    const std::string& identity_name,
                    const Identity& identity);
   void DeleteIdentity(const GURL& origin,
                       const std::string& identity_name,
                       const Identity& identity);
   void DeleteBetween(base::Time delete_begin, base::Time delete_end);
 
   void SetValidityPeriodForTesting(base::TimeDelta validity_period) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
+    DCHECK_CURRENTLY_ON(BrowserThread::DB);
     DCHECK(!db_.get());
     validity_period_ = validity_period;
   }
 
  private:
   friend class base::RefCountedThreadSafe<SqlLiteStorage>;
 
   enum OperationType {
     ADD_IDENTITY,
     DELETE_IDENTITY
@@ skipping 41 matching lines @@
     : validity_period_(validity_period),
       state_(NOT_STARTED),
       sql_lite_storage_(new SqlLiteStorage(validity_period, path, policy)) {
 }
 
 bool WebRTCIdentityStoreBackend::FindIdentity(
     const GURL& origin,
     const std::string& identity_name,
     const std::string& common_name,
     const FindIdentityCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (state_ == CLOSED)
     return false;
 
   if (state_ != LOADED) {
     // Queues the request to wait for the DB to load.
     pending_find_requests_.push_back(
         new PendingFindRequest(origin, identity_name, common_name, callback));
     if (state_ == LOADING)
       return true;
 
@@ skipping 40 matching lines @@
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(callback, net::ERR_FILE_NOT_FOUND, "", ""));
 }
 
 void WebRTCIdentityStoreBackend::AddIdentity(const GURL& origin,
                                              const std::string& identity_name,
                                              const std::string& common_name,
                                              const std::string& certificate,
                                              const std::string& private_key) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (state_ == CLOSED)
     return;
 
   // If there is an existing identity for the same origin and identity_name,
   // delete it.
   IdentityKey key(origin, identity_name);
   Identity identity(common_name, certificate, private_key);
 
   if (identities_.find(key) != identities_.end()) {
     if (!BrowserThread::PostTask(BrowserThread::DB,
@@ skipping 31 matching lines @@
   state_ = CLOSED;
   BrowserThread::PostTask(
       BrowserThread::DB,
       FROM_HERE,
       base::Bind(&SqlLiteStorage::Close, sql_lite_storage_));
 }
 
 void WebRTCIdentityStoreBackend::DeleteBetween(base::Time delete_begin,
                                                base::Time delete_end,
                                                const base::Closure& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (state_ == CLOSED)
     return;
 
   // Delete the in-memory cache.
   IdentityMap::iterator it = identities_.begin();
   while (it != identities_.end()) {
     if (it->second.creation_time >= delete_begin.ToInternalValue() &&
         it->second.creation_time <= delete_end.ToInternalValue()) {
       identities_.erase(it++);
     } else {
       ++it;
     }
   }
   BrowserThread::PostTaskAndReply(BrowserThread::DB,
                                   FROM_HERE,
                                   base::Bind(&SqlLiteStorage::DeleteBetween,
                                              sql_lite_storage_,
                                              delete_begin,
                                              delete_end),
                                   callback);
 }
 
 void WebRTCIdentityStoreBackend::SetValidityPeriodForTesting(
     base::TimeDelta validity_period) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   validity_period_ = validity_period;
   BrowserThread::PostTask(
       BrowserThread::DB,
       FROM_HERE,
       base::Bind(&SqlLiteStorage::SetValidityPeriodForTesting,
                  sql_lite_storage_,
                  validity_period));
 }
 
 WebRTCIdentityStoreBackend::~WebRTCIdentityStoreBackend() {}
 
 void WebRTCIdentityStoreBackend::OnLoaded(scoped_ptr<IdentityMap> out_map) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (state_ != LOADING)
     return;
 
   DVLOG(3) << "WebRTC identity store has loaded.";
 
   state_ = LOADED;
   identities_.swap(*out_map);
 
   for (size_t i = 0; i < pending_find_requests_.size(); ++i) {
     FindIdentity(pending_find_requests_[i]->origin,
                  pending_find_requests_[i]->identity_name,
                  pending_find_requests_[i]->common_name,
                  pending_find_requests_[i]->callback);
     delete pending_find_requests_[i];
   }
   pending_find_requests_.clear();
 }
 
 //
 // Implementation of SqlLiteStorage.
 //
 
 void WebRTCIdentityStoreBackend::SqlLiteStorage::Load(IdentityMap* out_map) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
+  DCHECK_CURRENTLY_ON(BrowserThread::DB);
   DCHECK(!db_.get());
 
   // Ensure the parent directory for storing certs is created before reading
   // from it.
   const base::FilePath dir = path_.DirName();
   if (!base::PathExists(dir) && !base::CreateDirectory(dir)) {
     DVLOG(2) << "Unable to open DB file path.";
     return;
   }
 
@@ skipping 33 matching lines @@
     stmt.ColumnBlobAsString(4, &private_key);
     int64 creation_time = stmt.ColumnInt64(5);
     std::pair<IdentityMap::iterator, bool> result =
         out_map->insert(std::pair<IdentityKey, Identity>(
             key, Identity(common_name, cert, private_key, creation_time)));
     DCHECK(result.second);
   }
 }
 
 void WebRTCIdentityStoreBackend::SqlLiteStorage::Close() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
+  DCHECK_CURRENTLY_ON(BrowserThread::DB);
   Commit();
   db_.reset();
 }
 
 void WebRTCIdentityStoreBackend::SqlLiteStorage::AddIdentity(
     const GURL& origin,
     const std::string& identity_name,
     const Identity& identity) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
+  DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (!db_.get())
     return;
 
   // Do not add for session only origins.
   if (special_storage_policy_.get() &&
       !special_storage_policy_->IsStorageProtected(origin) &&
       special_storage_policy_->IsStorageSessionOnly(origin)) {
     return;
   }
   BatchOperation(ADD_IDENTITY, origin, identity_name, identity);
 }
 
 void WebRTCIdentityStoreBackend::SqlLiteStorage::DeleteIdentity(
     const GURL& origin,
     const std::string& identity_name,
     const Identity& identity) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
+  DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (!db_.get())
     return;
   BatchOperation(DELETE_IDENTITY, origin, identity_name, identity);
 }
 
 void WebRTCIdentityStoreBackend::SqlLiteStorage::DeleteBetween(
     base::Time delete_begin,
     base::Time delete_end) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
+  DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (!db_.get())
     return;
 
   // Commit pending operations first.
   Commit();
 
   sql::Statement del_stmt(db_->GetCachedStatement(
       SQL_FROM_HERE,
       "DELETE FROM webrtc_identity_store"
       " WHERE creation_time >= ? AND creation_time <= ?"));
@@ skipping 13 matching lines @@
     return;
   }
 
   if (!transaction.Commit())
     DVLOG(2) << "Failed to commit the transaction.";
 }
 
 void WebRTCIdentityStoreBackend::SqlLiteStorage::OnDatabaseError(
     int error,
     sql::Statement* stmt) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
+  DCHECK_CURRENTLY_ON(BrowserThread::DB);
 
   db_->RazeAndClose();
   // It's not safe to reset |db_| here.
 }
 
 void WebRTCIdentityStoreBackend::SqlLiteStorage::BatchOperation(
     OperationType type,
     const GURL& origin,
     const std::string& identity_name,
     const Identity& identity) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
+  DCHECK_CURRENTLY_ON(BrowserThread::DB);
   // Commit every 30 seconds.
   static const base::TimeDelta kCommitInterval(
       base::TimeDelta::FromSeconds(30));
   // Commit right away if we have more than 512 outstanding operations.
   static const size_t kCommitAfterBatchSize = 512;
 
   // We do a full copy of the cert here, and hopefully just here.
   scoped_ptr<PendingOperation> operation(
       new PendingOperation(type, origin, identity_name, identity));
 
   pending_operations_.push_back(operation.release());
 
   if (pending_operations_.size() == 1) {
     // We've gotten our first entry for this batch, fire off the timer.
     BrowserThread::PostDelayedTask(BrowserThread::DB,
                                    FROM_HERE,
                                    base::Bind(&SqlLiteStorage::Commit, this),
                                    kCommitInterval);
   } else if (pending_operations_.size() >= kCommitAfterBatchSize) {
     // We've reached a big enough batch, fire off a commit now.
     BrowserThread::PostTask(BrowserThread::DB,
                             FROM_HERE,
                             base::Bind(&SqlLiteStorage::Commit, this));
   }
 }
 
 void WebRTCIdentityStoreBackend::SqlLiteStorage::Commit() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
+  DCHECK_CURRENTLY_ON(BrowserThread::DB);
   // Maybe an old timer fired or we are already Close()'ed.
   if (!db_.get() || pending_operations_.empty())
     return;
 
   sql::Statement add_stmt(db_->GetCachedStatement(
       SQL_FROM_HERE,
       "INSERT INTO webrtc_identity_store "
       "(origin, identity_name, common_name, certificate,"
       " private_key, creation_time) VALUES"
       " (?,?,?,?,?,?)"));
@@ skipping 52 matching lines @@
         NOTREACHED();
         break;
     }
   }
 
   if (!transaction.Commit())
     DVLOG(2) << "Failed to commit the transaction.";
 }
 
 }  // namespace content