Switch to standard integer types in content/browser/.

content/browser/accessibility/accessibility_win_browsertest.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 <stddef.h>
+#include <stdint.h>
+
 #include <vector>
 
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_variant.h"
 #include "content/browser/accessibility/accessibility_mode_helper.h"
 #include "content/browser/accessibility/accessibility_tree_formatter.h"
 #include "content/browser/accessibility/accessibility_tree_formatter_utils_win.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
@@ skipping 42 matching lines @@
       base::win::ScopedComPtr<IAccessibleText>* input_text);
   void SetUpTextareaField(
       base::win::ScopedComPtr<IAccessibleText>* textarea_text);
 
   static base::win::ScopedComPtr<IAccessible> GetAccessibleFromVariant(
       IAccessible* parent,
       VARIANT* var);
   static HRESULT QueryIAccessible2(IAccessible* accessible,
                                    IAccessible2** accessible2);
   static void FindNodeInAccessibilityTree(IAccessible* node,
-                                          int32 expected_role,
+                                          int32_t expected_role,
                                           const std::wstring& expected_name,
-                                          int32 depth,
+                                          int32_t depth,
                                           bool* found);
   static void CheckTextAtOffset(
       base::win::ScopedComPtr<IAccessibleText>& element,
       LONG offset,
       IA2TextBoundaryType boundary_type,
       LONG expected_start_offset,
       LONG expected_end_offset,
       const std::wstring& expected_text);
   static std::vector<base::win::ScopedVariant> GetAllAccessibleChildren(
       IAccessible* element);
@@ skipping 171 matching lines @@
   HRESULT hr = accessible->QueryInterface(service_provider.Receive());
   return SUCCEEDED(hr) ?
       service_provider->QueryService(IID_IAccessible2, accessible2) : hr;
 }
 
 // Recursively search through all of the descendants reachable from an
 // IAccessible node and return true if we find one with the given role
 // and name.
 void AccessibilityWinBrowserTest::FindNodeInAccessibilityTree(
     IAccessible* node,
-    int32 expected_role,
+    int32_t expected_role,
     const std::wstring& expected_name,
-    int32 depth,
+    int32_t depth,
     bool* found) {
   base::win::ScopedBstr name_bstr;
   base::win::ScopedVariant childid_self(CHILDID_SELF);
   node->get_accName(childid_self, name_bstr.Receive());
   std::wstring name(name_bstr, name_bstr.Length());
   base::win::ScopedVariant role;
   node->get_accRole(childid_self, role.Receive());
   ASSERT_EQ(VT_I4, role.type());
 
   // Print the accessibility tree as we go, because if this test fails
@@ skipping 75 matching lines @@
 }
 
 
 // AccessibleChecker ----------------------------------------------------------
 
 class AccessibilityWinBrowserTest::AccessibleChecker {
  public:
   // This constructor can be used if the IA2 role will be the same as the MSAA
   // role.
   AccessibleChecker(const std::wstring& expected_name,
-                    int32 expected_role,
+                    int32_t expected_role,
                     const std::wstring& expected_value);
   AccessibleChecker(const std::wstring& expected_name,
-                    int32 expected_role,
-                    int32 expected_ia2_role,
+                    int32_t expected_role,
+                    int32_t expected_ia2_role,
                     const std::wstring& expected_value);
   AccessibleChecker(const std::wstring& expected_name,
                     const std::wstring& expected_role,
-                    int32 expected_ia2_role,
+                    int32_t expected_ia2_role,
                     const std::wstring& expected_value);
 
   // Append an AccessibleChecker that verifies accessibility information for
   // a child IAccessible. Order is important.
   void AppendExpectedChild(AccessibleChecker* expected_child);
 
   // Check that the name and role of the given IAccessible instance and its
   // descendants match the expected names and roles that this object was
   // initialized with.
   void CheckAccessible(IAccessible* accessible);
@@ skipping 15 matching lines @@
   void CheckAccessibleChildren(IAccessible* accessible);
   base::string16 RoleVariantToString(const base::win::ScopedVariant& role);
 
   // Expected accessible name. Checked against IAccessible::get_accName.
   std::wstring name_;
 
   // Expected accessible role. Checked against IAccessible::get_accRole.
   base::win::ScopedVariant role_;
 
   // Expected IAccessible2 role. Checked against IAccessible2::role.
-  int32 ia2_role_;
+  int32_t ia2_role_;
 
   // Expected accessible value. Checked against IAccessible::get_accValue.
   std::wstring value_;
 
   // Expected accessible state. Checked against IAccessible::get_accState.
   LONG state_;
 
   // Expected accessible children. Checked using IAccessible::get_accChildCount
   // and ::AccessibleChildren.
   AccessibleCheckerVector children_;
 };
 
 AccessibilityWinBrowserTest::AccessibleChecker::AccessibleChecker(
     const std::wstring& expected_name,
-    int32 expected_role,
+    int32_t expected_role,
     const std::wstring& expected_value)
     : name_(expected_name),
       role_(expected_role),
       ia2_role_(expected_role),
       value_(expected_value),
-      state_(-1) {
-}
+      state_(-1) {}
 
 AccessibilityWinBrowserTest::AccessibleChecker::AccessibleChecker(
     const std::wstring& expected_name,
-    int32 expected_role,
-    int32 expected_ia2_role,
+    int32_t expected_role,
+    int32_t expected_ia2_role,
     const std::wstring& expected_value)
     : name_(expected_name),
       role_(expected_role),
       ia2_role_(expected_ia2_role),
       value_(expected_value),
-      state_(-1) {
-}
+      state_(-1) {}
 
 AccessibilityWinBrowserTest::AccessibleChecker::AccessibleChecker(
     const std::wstring& expected_name,
     const std::wstring& expected_role,
-    int32 expected_ia2_role,
+    int32_t expected_ia2_role,
     const std::wstring& expected_value)
     : name_(expected_name),
       role_(expected_role.c_str()),
       ia2_role_(expected_ia2_role),
       value_(expected_value),
-      state_(-1) {
-}
+      state_(-1) {}
 
 void AccessibilityWinBrowserTest::AccessibleChecker::AppendExpectedChild(
     AccessibleChecker* expected_child) {
   children_.push_back(expected_child);
 }
 
 void AccessibilityWinBrowserTest::AccessibleChecker::CheckAccessible(
     IAccessible* accessible) {
   SCOPED_TRACE("While checking "
                    + base::UTF16ToUTF8(RoleVariantToString(role_)));
@@ skipping 999 matching lines @@
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        TestMultiLineTextAtOffsetWithBoundaryAll) {
   base::win::ScopedComPtr<IAccessibleText> textarea_text;
   SetUpTextareaField(&textarea_text);
 
   CheckTextAtOffset(textarea_text, CONTENTS_LENGTH - 1, IA2_TEXT_BOUNDARY_ALL,
       0, CONTENTS_LENGTH, base::SysUTF8ToWide(TEXTAREA_CONTENTS));
 }
 
 }  // namespace content