Switch to standard integer types in win8/.

win8/metro_driver/ime/text_service.cc

 // Copyright 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 "win8/metro_driver/ime/text_service.h"
 
 #include <msctf.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/win/scoped_variant.h"
 #include "ui/metro_viewer/ime_types.h"
 #include "win8/metro_driver/ime/text_service_delegate.h"
 #include "win8/metro_driver/ime/text_store.h"
 #include "win8/metro_driver/ime/text_store_delegate.h"
 
 // Architecture overview of input method support on Ash mode:
 //
 // Overview:
 // On Ash mode, the system keyboard focus is owned by the metro_driver process
@@ skipping 126 matching lines @@
 
   base::win::ScopedComPtr<ITfCompartment> empty_context;
   hr = compartment_mgr->GetCompartment(GUID_COMPARTMENT_EMPTYCONTEXT,
                                        empty_context.Receive());
   if (FAILED(hr)) {
     LOG(ERROR) << "ITfCompartment::GetCompartment failed. hr = " << hr;
     return false;
   }
 
   base::win::ScopedVariant empty_context_variant;
-  empty_context_variant.Set(static_cast<int32>(1));
+  empty_context_variant.Set(static_cast<int32_t>(1));
   hr = empty_context->SetValue(client_id, empty_context_variant.ptr());
   if (FAILED(hr)) {
     LOG(ERROR) << "ITfCompartment::SetValue failed. hr = " << hr;
     return false;
   }
 
   return true;
 }
 
 bool IsPasswordField(const std::vector<InputScope>& input_scopes) {
@@ skipping 169 matching lines @@
     if (!current_document_) {
       VLOG(0) << "|current_document_| is NULL due to the previous error.";
       return;
     }
     scoped_refptr<TextStore> text_store = current_document_->text_store();
     if (!text_store.get())
       return;
     text_store->CancelComposition();
   }
 
-  void OnDocumentChanged(
-      const std::vector<int32>& input_scopes,
-      const std::vector<metro_viewer::CharacterBounds>& character_bounds)
-      override {
+  void OnDocumentChanged(const std::vector<int32_t>& input_scopes,
+                         const std::vector<metro_viewer::CharacterBounds>&
+                             character_bounds) override {
     bool document_type_changed = input_scopes_ != input_scopes;
     input_scopes_ = input_scopes;
     composition_character_bounds_ = character_bounds;
     if (document_type_changed)
       OnDocumentTypeChanged(input_scopes);
   }
 
   void OnWindowActivated() override {
     if (!current_document_) {
       VLOG(0) << "|current_document_| is NULL due to the previous error.";
       return;
     }
     ITfDocumentMgr* document_manager = current_document_->document_manager();
     if (!document_manager) {
       VLOG(0) << "|document_manager| is NULL due to the previous error.";
       return;
     }
     HRESULT hr = thread_manager_->SetFocus(document_manager);
     if (FAILED(hr)) {
       LOG(ERROR) << "ITfThreadMgr::SetFocus failed. hr = " << hr;
       return;
     }
   }
 
   void OnCompositionChanged(
       const base::string16& text,
-      int32 selection_start,
-      int32 selection_end,
+      int32_t selection_start,
+      int32_t selection_end,
       const std::vector<metro_viewer::UnderlineInfo>& underlines) override {
     if (!delegate_)
       return;
     delegate_->OnCompositionChanged(text,
                                     selection_start,
                                     selection_end,
                                     underlines);
   }
 
   void OnTextCommitted(const base::string16& text) override {
@@ skipping 15 matching lines @@
     ClientToScreen(window_handle_, &right_bottom);
     const RECT rect = {
       left_top.x,
       left_top.y,
       right_bottom.x,
       right_bottom.y,
     };
     return rect;
   }
 
-  bool GetCompositionCharacterBounds(uint32 index, RECT* rect) override {
+  bool GetCompositionCharacterBounds(uint32_t index, RECT* rect) override {
     if (index >= composition_character_bounds_.size()) {
       return false;
     }
     const metro_viewer::CharacterBounds& bounds =
         composition_character_bounds_[index];
     POINT left_top = { bounds.left, bounds.top };
     POINT right_bottom = { bounds.right, bounds.bottom };
     ClientToScreen(window_handle_, &left_top);
     ClientToScreen(window_handle_, &right_bottom);
     SetRect(rect, left_top.x, left_top.y, right_bottom.x, right_bottom.y);
     return true;
   }
 
-  void OnDocumentTypeChanged(const std::vector<int32>& input_scopes) {
+  void OnDocumentTypeChanged(const std::vector<int32_t>& input_scopes) {
     std::vector<InputScope> native_input_scopes(input_scopes.size());
     for (size_t i = 0; i < input_scopes.size(); ++i)
       native_input_scopes[i] = static_cast<InputScope>(input_scopes[i]);
     scoped_ptr<DocumentBinding> new_document =
         DocumentBinding::Create(thread_manager_.get(),
                                 client_id_,
                                 native_input_scopes,
                                 window_handle_,
                                 this);
     LOG_IF(ERROR, !new_document) << "Failed to create a new document.";
     current_document_.swap(new_document);
     OnWindowActivated();
   }
 
   TfClientId client_id_;
   HWND window_handle_;
   TextServiceDelegate* delegate_;
   scoped_ptr<DocumentBinding> current_document_;
   base::win::ScopedComPtr<ITfThreadMgr> thread_manager_;
 
   // A vector of InputScope enumeration, which represents the document type of
   // the focused text field. Note that in our IPC message protocol, an empty
   // |input_scopes_| has special meaning that IMEs must be disabled on this
   // document.
-  std::vector<int32> input_scopes_;
+  std::vector<int32_t> input_scopes_;
   // Character bounds of the composition. When there is no composition but this
   // vector is not empty, the first element contains the caret bounds.
   std::vector<metro_viewer::CharacterBounds> composition_character_bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(TextServiceImpl);
 };
 
 }  // namespace
 
 scoped_ptr<TextService>
@@ skipping 16 matching lines @@
   if (!InitializeSentenceMode(thread_manager.get(), client_id)) {
     LOG(ERROR) << "InitializeSentenceMode failed.";
     thread_manager->Deactivate();
     return scoped_ptr<TextService>();
   }
   return scoped_ptr<TextService>(new TextServiceImpl(
       thread_manager.get(), client_id, window_handle, delegate));
 }
 
 }  // namespace metro_driver