Switch to standard integer types in chrome/.

chrome/test/chromedriver/chrome_launcher.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/test/chromedriver/chrome_launcher.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <vector>
 
 #include "base/base64.h"
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/format_macros.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/process/process.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "base/values.h"
+#include "build/build_config.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/test/chromedriver/chrome/chrome_android_impl.h"
 #include "chrome/test/chromedriver/chrome/chrome_desktop_impl.h"
 #include "chrome/test/chromedriver/chrome/chrome_finder.h"
 #include "chrome/test/chromedriver/chrome/chrome_remote_impl.h"
 #include "chrome/test/chromedriver/chrome/device_manager.h"
 #include "chrome/test/chromedriver/chrome/devtools_client_impl.h"
 #include "chrome/test/chromedriver/chrome/devtools_event_listener.h"
 #include "chrome/test/chromedriver/chrome/devtools_http_client.h"
 #include "chrome/test/chromedriver/chrome/embedded_automation_extension.h"
@@ skipping 65 matching lines @@
   }
 
   base::FilePath extension_dir = temp_dir.AppendASCII("internal");
   if (!zip::Unzip(extension_zip, extension_dir))
     return Status(kUnknownError, "failed to unzip automation extension");
 
   *automation_extension = extension_dir;
   return Status(kOk);
 }
 
-Status PrepareCommandLine(uint16 port,
+Status PrepareCommandLine(uint16_t port,
                           const Capabilities& capabilities,
                           base::CommandLine* prepared_command,
                           base::ScopedTempDir* user_data_dir,
                           base::ScopedTempDir* extension_dir,
                           std::vector<std::string>* extension_bg_pages) {
   base::FilePath program = capabilities.binary;
   if (program.empty()) {
     if (!FindChrome(&program))
       return Status(kUnknownError, "cannot find Chrome binary");
   } else if (!base::PathExists(program)) {
@@ skipping 161 matching lines @@
   }
 
   chrome->reset(new ChromeRemoteImpl(devtools_http_client.Pass(),
                                      devtools_websocket_client.Pass(),
                                      *devtools_event_listeners));
   return Status(kOk);
 }
 
 Status LaunchDesktopChrome(
     URLRequestContextGetter* context_getter,
-    uint16 port,
+    uint16_t port,
     scoped_ptr<PortReservation> port_reservation,
     const SyncWebSocketFactory& socket_factory,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>* devtools_event_listeners,
     scoped_ptr<Chrome>* chrome) {
   base::CommandLine command(base::CommandLine::NO_PROGRAM);
   base::ScopedTempDir user_data_dir;
   base::ScopedTempDir extension_dir;
   std::vector<std::string> extension_bg_pages;
   Status status = PrepareCommandLine(port,
@@ skipping 134 matching lines @@
                         extension_bg_pages[i],
                     status);
     }
   }
   *chrome = chrome_desktop.Pass();
   return Status(kOk);
 }
 
 Status LaunchAndroidChrome(
     URLRequestContextGetter* context_getter,
-    uint16 port,
+    uint16_t port,
     scoped_ptr<PortReservation> port_reservation,
     const SyncWebSocketFactory& socket_factory,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>* devtools_event_listeners,
     DeviceManager* device_manager,
     scoped_ptr<Chrome>* chrome) {
   Status status(kOk);
   scoped_ptr<Device> device;
   if (capabilities.android_device_serial.empty()) {
     status = device_manager->AcquireDevice(&device);
@@ skipping 58 matching lines @@
     PortManager* port_manager,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>* devtools_event_listeners,
     scoped_ptr<Chrome>* chrome) {
   if (capabilities.IsRemoteBrowser()) {
     return LaunchRemoteChromeSession(
         context_getter, socket_factory,
         capabilities, devtools_event_listeners, chrome);
   }
 
-  uint16 port = 0;
+  uint16_t port = 0;
   scoped_ptr<PortReservation> port_reservation;
   Status port_status(kOk);
 
   if (capabilities.IsAndroid()) {
     if (port_server)
       port_status = port_server->ReservePort(&port, &port_reservation);
     else
       port_status = port_manager->ReservePortFromPool(&port, &port_reservation);
     if (port_status.IsError())
       return Status(kUnknownError, "cannot reserve port for Chrome",
@@ skipping 33 matching lines @@
                                                id->begin() + i + 1),
                              &val)) {
       (*id)[i] = val + 'a';
     } else {
       (*id)[i] = 'a';
     }
   }
 }
 
 std::string GenerateExtensionId(const std::string& input) {
-  uint8 hash[16];
+  uint8_t hash[16];
   crypto::SHA256HashString(input, hash, sizeof(hash));
   std::string output = base::ToLowerASCII(base::HexEncode(hash, sizeof(hash)));
   ConvertHexadecimalToIDAlphabet(&output);
   return output;
 }
 
 Status GetExtensionBackgroundPage(const base::DictionaryValue* manifest,
                                   const std::string& id,
                                   std::string* bg_page) {
   std::string bg_page_name;
@@ skipping 31 matching lines @@
   if (magic_header.size() != 4)
     return Status(kUnknownError, "cannot extract magic number");
 
   const bool is_crx_file = magic_header == "Cr24";
 
   if (is_crx_file) {
     // Assume a CRX v2 file - see https://developer.chrome.com/extensions/crx.
     std::string key_len_str = decoded_extension.substr(8, 4);
     if (key_len_str.size() != 4)
       return Status(kUnknownError, "cannot extract public key length");
-    uint32 key_len = *reinterpret_cast<const uint32*>(key_len_str.c_str());
+    uint32_t key_len = *reinterpret_cast<const uint32_t*>(key_len_str.c_str());
     public_key = decoded_extension.substr(16, key_len);
     if (key_len != public_key.size())
       return Status(kUnknownError, "invalid public key length");
   } else {
     // Not a CRX file. Generate RSA keypair to get a valid extension id.
     scoped_ptr<crypto::RSAPrivateKey> key_pair(
         crypto::RSAPrivateKey::Create(2048));
     if (!key_pair)
       return Status(kUnknownError, "cannot generate RSA key pair");
-    std::vector<uint8> public_key_vector;
+    std::vector<uint8_t> public_key_vector;
     if (!key_pair->ExportPublicKey(&public_key_vector))
       return Status(kUnknownError, "cannot extract public key");
     public_key =
         std::string(reinterpret_cast<char*>(&public_key_vector.front()),
                     public_key_vector.size());
   }
   std::string public_key_base64;
   base::Base64Encode(public_key, &public_key_base64);
   std::string id = GenerateExtensionId(public_key);
 
@@ skipping 194 matching lines @@
   // Write empty "First Run" file, otherwise Chrome will wipe the default
   // profile that was written.
   if (base::WriteFile(
           user_data_dir.Append(chrome::kFirstRunSentinel), "", 0) != 0) {
     return Status(kUnknownError, "failed to write first run file");
   }
   return Status(kOk);
 }
 
 }  // namespace internal