Stop passing raw pointers to DictionaryValue::Set, part 2

chrome/browser/chromeos/extensions/external_cache.cc

 // Copyright (c) 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/chromeos/extensions/external_cache.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 247 matching lines @@
 
       if (update_url.is_valid())
         downloader_->AddPendingExtension(it.key(), update_url, false, 0);
     }
 
     base::FilePath file_path;
     std::string version;
     std::string hash;
     if (local_cache_.GetExtension(it.key(), hash, &file_path, &version)) {
       // Copy entry to don't modify it inside extensions_.
-      base::DictionaryValue* entry_copy = entry->DeepCopy();
+      std::unique_ptr<base::DictionaryValue> entry_copy =
+          entry->CreateDeepCopy();
 
       if (extension_urls::IsWebstoreUpdateUrl(GURL(external_update_url))) {
         entry_copy->SetBoolean(
             extensions::ExternalProviderImpl::kIsFromWebstore, true);
       }
       entry_copy->Remove(extensions::ExternalProviderImpl::kExternalUpdateUrl,
                          NULL);
       entry_copy->SetString(extensions::ExternalProviderImpl::kExternalVersion,
                             version);
       entry_copy->SetString(extensions::ExternalProviderImpl::kExternalCrx,
                             file_path.value());
-      cached_extensions_->Set(it.key(), entry_copy);
+      cached_extensions_->Set(it.key(), std::move(entry_copy));
     } else {
       bool has_external_crx = entry->HasKey(
           extensions::ExternalProviderImpl::kExternalCrx);
       bool is_already_installed =
           !delegate_->GetInstalledExtensionVersion(it.key()).empty();
       if (keep_if_present || has_external_crx || is_already_installed) {
         // Copy entry to don't modify it inside extensions_.
-        cached_extensions_->Set(it.key(), entry->DeepCopy());
+        cached_extensions_->Set(it.key(), entry->CreateDeepCopy());
       }
     }
   }
 
   if (downloader_)
     downloader_->StartAllPending(NULL);
 
   VLOG(1) << "Updated ExternalCache, there are "
           << cached_extensions_->size() << " extensions cached";
 
   UpdateExtensionLoader();
 }
 
 void ExternalCache::OnPutExtension(const std::string& id,
                                    const base::FilePath& file_path,
                                    bool file_ownership_passed) {
   if (local_cache_.is_shutdown() || file_ownership_passed) {
     backend_task_runner_->PostTask(FROM_HERE,
         base::Bind(base::IgnoreResult(&base::DeleteFile), file_path, true));
     return;
   }
 
   VLOG(1) << "ExternalCache installed a new extension in the cache " << id;
 
-  base::DictionaryValue* entry = NULL;
-  if (!extensions_->GetDictionary(id, &entry)) {
+  base::DictionaryValue* original_entry = NULL;
+  if (!extensions_->GetDictionary(id, &original_entry)) {
     LOG(ERROR) << "ExternalCache cannot find entry for extension " << id;
     return;
   }
 
-  // Copy entry to don't modify it inside extensions_.
-  entry = entry->DeepCopy();
+  // Copy original_entry to avoid modifying it inside extensions_.
+  std::unique_ptr<base::DictionaryValue> entry =
+      original_entry->CreateDeepCopy();
 
   std::string version;
   std::string hash;
   if (!local_cache_.GetExtension(id, hash, NULL, &version)) {
     // Copy entry to don't modify it inside extensions_.
     LOG(ERROR) << "Can't find installed extension in cache " << id;
     return;
   }
 
   if (flush_on_put_) {
     backend_task_runner_->PostTask(FROM_HERE,
                                    base::Bind(&FlushFile, file_path));
   }
 
   std::string update_url;
   if (entry->GetString(extensions::ExternalProviderImpl::kExternalUpdateUrl,
                        &update_url) &&
       extension_urls::IsWebstoreUpdateUrl(GURL(update_url))) {
     entry->SetBoolean(extensions::ExternalProviderImpl::kIsFromWebstore, true);
   }
   entry->Remove(extensions::ExternalProviderImpl::kExternalUpdateUrl, NULL);
   entry->SetString(extensions::ExternalProviderImpl::kExternalVersion, version);
   entry->SetString(extensions::ExternalProviderImpl::kExternalCrx,
                    file_path.value());
 
-  cached_extensions_->Set(id, entry);
+  cached_extensions_->Set(id, std::move(entry));
   if (delegate_)
     delegate_->OnExtensionLoadedInCache(id);
   UpdateExtensionLoader();
 }
 
 void ExternalCache::OnPutExternalExtension(
     const std::string& id,
     const PutExternalExtensionCallback& callback,
     const base::FilePath& file_path,
     bool file_ownership_passed) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   OnPutExtension(id, file_path, file_ownership_passed);
   callback.Run(id, !file_ownership_passed);
 }
 
 std::string ExternalCache::Delegate::GetInstalledExtensionVersion(
     const std::string& id) {
   return std::string();
 }
 
 }  // namespace chromeos