Make //crypto factories return std::unique_ptr<>s

net/ssl/default_channel_id_store.cc

 // Copyright 2014 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 "net/ssl/default_channel_id_store.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 224 matching lines @@
         new GetChannelIDTask(server_identifier, callback)));
     return ERR_IO_PENDING;
   }
 
   ChannelIDMap::iterator it = channel_ids_.find(server_identifier);
 
   if (it == channel_ids_.end())
     return ERR_FILE_NOT_FOUND;
 
   ChannelID* channel_id = it->second;
-  key_result->reset(channel_id->key()->Copy());
+  *key_result = channel_id->key()->Copy();
 
   return OK;
 }
 
 void DefaultChannelIDStore::SetChannelID(
     std::unique_ptr<ChannelID> channel_id) {
   auto task = new SetChannelIDTask(std::move(channel_id));
   RunOrEnqueueTask(std::unique_ptr<Task>(task));
 }
 
@@ skipping 27 matching lines @@
 int DefaultChannelIDStore::GetChannelIDCount() {
   DCHECK(CalledOnValidThread());
 
   return channel_ids_.size();
 }
 
 void DefaultChannelIDStore::SetForceKeepSessionState() {
   DCHECK(CalledOnValidThread());
   InitIfNecessary();
 
-  if (store_.get())
+  if (store_)
     store_->SetForceKeepSessionState();
 }
 
 DefaultChannelIDStore::~DefaultChannelIDStore() {
   DeleteAllInMemory();
 }
 
 void DefaultChannelIDStore::DeleteAllInMemory() {
   DCHECK(CalledOnValidThread());
 
   for (ChannelIDMap::iterator it = channel_ids_.begin();
        it != channel_ids_.end(); ++it) {
     delete it->second;
   }
   channel_ids_.clear();
 }
 
 void DefaultChannelIDStore::InitStore() {
   DCHECK(CalledOnValidThread());
-  DCHECK(store_.get()) << "Store must exist to initialize";
+  DCHECK(store_) << "Store must exist to initialize";
   DCHECK(!loaded_);
 
   store_->Load(base::Bind(&DefaultChannelIDStore::OnLoaded,
                           weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DefaultChannelIDStore::OnLoaded(
     std::unique_ptr<std::vector<std::unique_ptr<ChannelID>>> channel_ids) {
   DCHECK(CalledOnValidThread());
   for (std::vector<std::unique_ptr<ChannelID>>::iterator it =
@@ skipping 50 matching lines @@
   for (ChannelIDMap::iterator it = channel_ids_.begin();
        it != channel_ids_.end();) {
     ChannelIDMap::iterator cur = it;
     ++it;
     ChannelID* channel_id = cur->second;
 
     if ((delete_begin.is_null() ||
          channel_id->creation_time() >= delete_begin) &&
         (delete_end.is_null() || channel_id->creation_time() < delete_end) &&
         domain_predicate.Run(channel_id->server_identifier())) {
-      if (store_.get())
+      if (store_)
         store_->DeleteChannelID(*channel_id);
       delete channel_id;
       channel_ids_.erase(cur);
     }
   }
 }
 
 void DefaultChannelIDStore::SyncGetAllChannelIDs(
     ChannelIDList* channel_id_list) {
   DCHECK(CalledOnValidThread());
@@ skipping 26 matching lines @@
 void DefaultChannelIDStore::InternalDeleteChannelID(
     const std::string& server_identifier) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded_);
 
   ChannelIDMap::iterator it = channel_ids_.find(server_identifier);
   if (it == channel_ids_.end())
     return;  // There is nothing to delete.
 
   ChannelID* channel_id = it->second;
-  if (store_.get())
+  if (store_)
     store_->DeleteChannelID(*channel_id);
   channel_ids_.erase(it);
   delete channel_id;
 }
 
 void DefaultChannelIDStore::InternalInsertChannelID(
     std::unique_ptr<ChannelID> channel_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded_);
 
-  if (store_.get())
-    store_->AddChannelID(*(channel_id.get()));
+  if (store_)
+    store_->AddChannelID(*channel_id);
   const std::string& server_identifier = channel_id->server_identifier();
   channel_ids_[server_identifier] = channel_id.release();
 }
 
 bool DefaultChannelIDStore::IsEphemeral() {
-  return store_.get() == nullptr;
+  return !store_;
 }
 
 DefaultChannelIDStore::PersistentStore::PersistentStore() {}
 
 DefaultChannelIDStore::PersistentStore::~PersistentStore() {}
 
 }  // namespace net