Cleanup: Remove unnecessary ".get()" from scoped_ptrs<>.

chrome/browser/extensions/extension_creator.cc

 // Copyright (c) 2012 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/extension_creator.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 132 matching lines @@
   }
 
   return crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(
       std::vector<uint8>(private_key_bytes.begin(), private_key_bytes.end()));
 }
 
 crypto::RSAPrivateKey* ExtensionCreator::GenerateKey(const base::FilePath&
     output_private_key_path) {
   scoped_ptr<crypto::RSAPrivateKey> key_pair(
       crypto::RSAPrivateKey::Create(kRSAKeySize));
-  if (!key_pair.get()) {
+  if (!key_pair) {
     error_message_ =
         l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_FAILED_TO_GENERATE);
     return NULL;
   }
 
   std::vector<uint8> private_key_vector;
   if (!key_pair->ExportPrivateKey(&private_key_vector)) {
     error_message_ =
         l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_FAILED_TO_EXPORT);
     return NULL;
@@ skipping 79 matching lines @@
     error_message_ = l10n_util::GetStringUTF8(IDS_EXTENSION_SHARING_VIOLATION);
     return false;
   }
 
   std::vector<uint8> public_key;
   CHECK(private_key->ExportPublicKey(&public_key));
 
   CrxFile::Error error;
   scoped_ptr<CrxFile> crx(
       CrxFile::Create(public_key.size(), signature.size(), &error));
-  if (!crx.get()) {
+  if (!crx) {
     LOG(ERROR) << "cannot create CrxFileHeader: " << error;
   }
   const CrxFile::Header header = crx->header();
 
   if (fwrite(&header, sizeof(header), 1, crx_handle.get()) != 1) {
     PLOG(ERROR) << "fwrite failed to write header";
   }
   if (fwrite(&public_key.front(), sizeof(uint8), public_key.size(),
              crx_handle.get()) != public_key.size()) {
     PLOG(ERROR) << "fwrite failed to write public_key.front";
@@ skipping 28 matching lines @@
                        output_private_key_path, run_flags)) {
     return false;
   }
 
   // Initialize Key Pair
   scoped_ptr<crypto::RSAPrivateKey> key_pair;
   if (!private_key_path.value().empty())
     key_pair.reset(ReadInputKey(private_key_path));
   else
     key_pair.reset(GenerateKey(output_private_key_path));
-  if (!key_pair.get())
+  if (!key_pair)
     return false;
 
   // Perform some extra validation by loading the extension.
   // TODO(aa): Can this go before creating the key pair? This would mean not
   // passing ID into LoadExtension which seems OK.
   if (!ValidateManifest(extension_dir, key_pair.get(), run_flags))
     return false;
 
   base::ScopedTempDir temp_dir;
   if (!temp_dir.CreateUniqueTempDir())
     return false;
 
   // Zip up the extension.
   base::FilePath zip_path;
   std::vector<uint8> signature;
   bool result = false;
   if (CreateZip(extension_dir, temp_dir.path(), &zip_path) &&
       SignZip(zip_path, key_pair.get(), &signature) &&
       WriteCRX(zip_path, key_pair.get(), signature, crx_path)) {
     result = true;
   }
 
   file_util::Delete(zip_path, false);
   return result;
 }
 
 }  // namespace extensions