Switch to standard integer types in win8/.

win8/metro_driver/ime/text_store.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_store.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 
 #include "base/win/scoped_variant.h"
 #include "ui/base/win/atl_module.h"
 #include "win8/metro_driver/ime/input_scope.h"
 #include "win8/metro_driver/ime/text_store_delegate.h"
 
 namespace metro_driver {
 namespace {
 
@@ skipping 280 matching lines @@
     return TS_E_INVALIDPOS;
   }
 
   // According to a behavior of notepad.exe and wordpad.exe, top left corner of
   // rect indicates a first character's one, and bottom right corner of rect
   // indicates a last character's one.
   // We use RECT instead of gfx::Rect since left position may be bigger than
   // right position when composition has multiple lines.
   RECT result;
   RECT tmp_rect;
-  const uint32 start_pos = acp_start - committed_size_;
-  const uint32 end_pos = acp_end - committed_size_;
+  const uint32_t start_pos = acp_start - committed_size_;
+  const uint32_t end_pos = acp_end - committed_size_;
 
   if (start_pos == end_pos) {
     // According to MSDN document, if |acp_start| and |acp_end| are equal it is
     // OK to just return E_INVALIDARG.
     // http://msdn.microsoft.com/en-us/library/ms538435
     // But when using Pinin IME of Windows 8, this method is called with the
     // equal values of |acp_start| and |acp_end|. So we handle this condition.
     if (start_pos == 0) {
       if (delegate_->GetCompositionCharacterBounds(0, &tmp_rect)) {
         tmp_rect.right = tmp_rect.right;
@@ skipping 174 matching lines @@
     // Queue the lock request.
     lock_queue_.push_back(lock_flags & TS_LF_READWRITE);
     *result = TS_S_ASYNC;
     return S_OK;
   }
 
   // Lock
   current_lock_type_ = (lock_flags & TS_LF_READWRITE);
 
   edit_flag_ = false;
-  const uint32 last_committed_size = committed_size_;
+  const uint32_t last_committed_size = committed_size_;
 
   // Grant the lock.
   *result = text_store_acp_sink_->OnLockGranted(current_lock_type_);
 
   // Unlock
   current_lock_type_ = 0;
 
   // Handles the pending lock requests.
   while (!lock_queue_.empty()) {
     current_lock_type_ = lock_queue_.front();
     lock_queue_.pop_front();
     text_store_acp_sink_->OnLockGranted(current_lock_type_);
     current_lock_type_ = 0;
   }
 
   if (!edit_flag_)
     return S_OK;
 
   // If the text store is edited in OnLockGranted(), we may need to call
   // TextStoreDelegate::ConfirmComposition() or
   // TextStoreDelegate::SetComposition().
-  const uint32 new_committed_size = committed_size_;
+  const uint32_t new_committed_size = committed_size_;
   const base::string16& new_committed_string =
       string_buffer_.substr(last_committed_size,
                             new_committed_size - last_committed_size);
   const base::string16& composition_string =
       string_buffer_.substr(new_committed_size);
 
   // If there is new committed string, calls
   // TextStoreDelegate::ConfirmComposition().
   if ((!new_committed_string.empty()))
     delegate_->OnTextCommitted(new_committed_string);
 
   // Calls TextInputClient::SetCompositionText().
   std::vector<metro_viewer::UnderlineInfo> underlines = underlines_;
   // Adjusts the offset.
   for (size_t i = 0; i < underlines_.size(); ++i) {
     underlines[i].start_offset -= new_committed_size;
     underlines[i].end_offset -= new_committed_size;
   }
-  int32 selection_start = 0;
-  int32 selection_end = 0;
+  int32_t selection_start = 0;
+  int32_t selection_end = 0;
   if (selection_start_ >= new_committed_size)
     selection_start = selection_start_ - new_committed_size;
   if (selection_end_ >= new_committed_size)
     selection_end = selection_end_ - new_committed_size;
   delegate_->OnCompositionChanged(
         composition_string, selection_start, selection_end, underlines);
 
   // If there is no composition string, clear the text store status.
   // And call OnSelectionChange(), OnLayoutChange(), and OnTextChange().
   if ((composition_string.empty()) && (new_committed_size != 0)) {
@@ skipping 164 matching lines @@
   if (FAILED(display_attribute_manager_->GetDisplayAttributeInfo(
           guid, display_attribute_info.Receive(), NULL))) {
     return false;
   }
   return SUCCEEDED(display_attribute_info->GetAttributeInfo(attribute));
 }
 
 bool TextStore::GetCompositionStatus(
     ITfContext* context,
     const TfEditCookie read_only_edit_cookie,
-    uint32* committed_size,
+    uint32_t* committed_size,
     std::vector<metro_viewer::UnderlineInfo>* undelines) {
   DCHECK(context);
   DCHECK(committed_size);
   DCHECK(undelines);
   const GUID* rgGuids[2] = {&GUID_PROP_COMPOSING, &GUID_PROP_ATTRIBUTE};
   base::win::ScopedComPtr<ITfReadOnlyProperty> track_property;
   if (FAILED(context->TrackProperties(rgGuids, 2, NULL, 0,
                                       track_property.Receive()))) {
     return false;
   }
@@ skipping 71 matching lines @@
     return true;
 
   // Unlike ImmNotifyIME(NI_COMPOSITIONSTR, CPS_CANCEL, 0) in IMM32, TSF does
   // not have a dedicated method to cancel composition. However, CUAS actually
   // has a protocol conversion from CPS_CANCEL into TSF operations. According
   // to the observations on Windows 7, TIPs are expected to cancel composition
   // when an on-going composition text is replaced with an empty string. So
   // we use the same operation to cancel composition here to minimize the risk
   // of potential compatibility issues.
 
-  const uint32 previous_buffer_size =
-      static_cast<uint32>(string_buffer_.size());
+  const uint32_t previous_buffer_size =
+      static_cast<uint32_t>(string_buffer_.size());
   string_buffer_.clear();
   committed_size_ = 0;
   selection_start_ = 0;
   selection_end_ = 0;
   if (text_store_acp_sink_mask_ & TS_AS_SEL_CHANGE)
     text_store_acp_sink_->OnSelectionChange();
   if (text_store_acp_sink_mask_ & TS_AS_LAYOUT_CHANGE)
     text_store_acp_sink_->OnLayoutChange(TS_LC_CHANGE, 0);
   if (text_store_acp_sink_mask_ & TS_AS_TEXT_CHANGE) {
     TS_TEXTCHANGE textChange = {};
@@ skipping 15 matching lines @@
 
   // See the comment in TextStore::CancelComposition.
   // This logic is based on the observation about how to emulate
   // ImmNotifyIME(NI_COMPOSITIONSTR, CPS_COMPLETE, 0) by CUAS.
 
   const base::string16& composition_text =
       string_buffer_.substr(committed_size_);
   if (!composition_text.empty())
     delegate_->OnTextCommitted(composition_text);
 
-  const uint32 previous_buffer_size =
-      static_cast<uint32>(string_buffer_.size());
+  const uint32_t previous_buffer_size =
+      static_cast<uint32_t>(string_buffer_.size());
   string_buffer_.clear();
   committed_size_ = 0;
   selection_start_ = 0;
   selection_end_ = 0;
   if (text_store_acp_sink_mask_ & TS_AS_SEL_CHANGE)
     text_store_acp_sink_->OnSelectionChange();
   if (text_store_acp_sink_mask_ & TS_AS_LAYOUT_CHANGE)
     text_store_acp_sink_->OnLayoutChange(TS_LC_CHANGE, 0);
   if (text_store_acp_sink_mask_ & TS_AS_TEXT_CHANGE) {
     TS_TEXTCHANGE textChange = {};
@@ skipping 14 matching lines @@
 
 bool TextStore::HasReadLock() const {
   return (current_lock_type_ & TS_LF_READ) == TS_LF_READ;
 }
 
 bool TextStore::HasReadWriteLock() const {
   return (current_lock_type_ & TS_LF_READWRITE) == TS_LF_READWRITE;
 }
 
 }  // namespace metro_driver