Remove base/memory/scoped_handle.h

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"
 #include "base/callback.h"
 #include "base/file_util.h"
+#include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
-#include "base/memory/scoped_handle.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/extensions/extension_creator_filter.h"
 #include "crypto/rsa_private_key.h"
 #include "crypto/signature_creator.h"
 #include "extensions/common/crx_file.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/file_util.h"
 #include "extensions/common/id_util.h"
 #include "grit/generated_resources.h"
 #include "third_party/zlib/google/zip.h"
@@ skipping 180 matching lines @@
   }
 
   return true;
 }
 
 bool ExtensionCreator::SignZip(const base::FilePath& zip_path,
                                crypto::RSAPrivateKey* private_key,
                                std::vector<uint8>* signature) {
   scoped_ptr<crypto::SignatureCreator> signature_creator(
       crypto::SignatureCreator::Create(private_key));
-  ScopedStdioHandle zip_handle(base::OpenFile(zip_path, "rb"));
+  base::ScopedFILE zip_handle(base::OpenFile(zip_path, "rb"));
   size_t buffer_size = 1 << 16;
   scoped_ptr<uint8[]> buffer(new uint8[buffer_size]);
   int bytes_read = -1;
   while ((bytes_read = fread(buffer.get(), 1, buffer_size,
        zip_handle.get())) > 0) {
     if (!signature_creator->Update(buffer.get(), bytes_read)) {
       error_message_ =
           l10n_util::GetStringUTF8(IDS_EXTENSION_ERROR_WHILE_SIGNING);
       return false;
     }
   }
-  zip_handle.Close();
+  zip_handle.reset();
 
   if (!signature_creator->Final(signature)) {
     error_message_ =
         l10n_util::GetStringUTF8(IDS_EXTENSION_ERROR_WHILE_SIGNING);
     return false;
   }
   return true;
 }
 
 bool ExtensionCreator::WriteCRX(const base::FilePath& zip_path,
                                 crypto::RSAPrivateKey* private_key,
                                 const std::vector<uint8>& signature,
                                 const base::FilePath& crx_path) {
   if (base::PathExists(crx_path))
     base::DeleteFile(crx_path, false);
-  ScopedStdioHandle crx_handle(base::OpenFile(crx_path, "wb"));
+  base::ScopedFILE crx_handle(base::OpenFile(crx_path, "wb"));
   if (!crx_handle.get()) {
     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(
@@ skipping 11 matching lines @@
     PLOG(ERROR) << "fwrite failed to write public_key.front";
   }
   if (fwrite(&signature.front(), sizeof(uint8), signature.size(),
              crx_handle.get()) != signature.size()) {
     PLOG(ERROR) << "fwrite failed to write signature.front";
   }
 
   size_t buffer_size = 1 << 16;
   scoped_ptr<uint8[]> buffer(new uint8[buffer_size]);
   size_t bytes_read = 0;
-  ScopedStdioHandle zip_handle(base::OpenFile(zip_path, "rb"));
+  base::ScopedFILE zip_handle(base::OpenFile(zip_path, "rb"));
   while ((bytes_read = fread(buffer.get(), 1, buffer_size,
                              zip_handle.get())) > 0) {
     if (fwrite(buffer.get(), sizeof(char), bytes_read, crx_handle.get()) !=
         bytes_read) {
       PLOG(ERROR) << "fwrite failed to write buffer";
     }
   }
 
   return true;
 }
@@ skipping 36 matching lines @@
       SignZip(zip_path, key_pair.get(), &signature) &&
       WriteCRX(zip_path, key_pair.get(), signature, crx_path)) {
     result = true;
   }
 
   base::DeleteFile(zip_path, false);
   return result;
 }
 
 }  // namespace extensions