Switch to standard integer types in content/browser/.

content/browser/frame_host/render_frame_host_impl.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 "content/browser/frame_host/render_frame_host_impl.h"
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
 #include "base/process/kill.h"
 #include "base/time/time.h"
+#include "build/build_config.h"
 #include "content/browser/accessibility/accessibility_mode_helper.h"
 #include "content/browser/accessibility/ax_tree_id_registry.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/devtools/render_frame_devtools_agent_host.h"
 #include "content/browser/download/mhtml_generation_manager.h"
 #include "content/browser/frame_host/cross_process_frame_connector.h"
 #include "content/browser/frame_host/cross_site_transferring_request.h"
@@ skipping 75 matching lines @@
 int g_next_accessibility_reset_token = 1;
 
 // The next value to use for the javascript callback id.
 int g_next_javascript_callback_id = 1;
 
 // Whether to allow injecting javascript into any kind of frame (for Android
 // WebView).
 bool g_allow_injecting_javascript = false;
 
 // The (process id, routing id) pair that identifies one RenderFrame.
-typedef std::pair<int32, int32> RenderFrameHostID;
+typedef std::pair<int32_t, int32_t> RenderFrameHostID;
 typedef base::hash_map<RenderFrameHostID, RenderFrameHostImpl*>
     RoutingIDFrameMap;
 base::LazyInstance<RoutingIDFrameMap> g_routing_id_frame_map =
     LAZY_INSTANCE_INITIALIZER;
 
 // Translate a WebKit text direction into a base::i18n one.
 base::i18n::TextDirection WebTextDirectionToChromeTextDirection(
     blink::WebTextDirection dir) {
   switch (dir) {
     case blink::WebTextDirectionLeftToRight:
@@ skipping 50 matching lines @@
       AXTreeIDRegistry::GetInstance()->GetFrameID(ax_tree_id);
   return RenderFrameHostImpl::FromID(frame_id.first, frame_id.second);
 }
 
 RenderFrameHostImpl::RenderFrameHostImpl(SiteInstance* site_instance,
                                          RenderViewHostImpl* render_view_host,
                                          RenderFrameHostDelegate* delegate,
                                          RenderWidgetHostDelegate* rwh_delegate,
                                          FrameTree* frame_tree,
                                          FrameTreeNode* frame_tree_node,
-                                         int32 routing_id,
-                                         int32 widget_routing_id,
+                                         int32_t routing_id,
+                                         int32_t widget_routing_id,
                                          int flags)
     : render_view_host_(render_view_host),
       delegate_(delegate),
       site_instance_(static_cast<SiteInstanceImpl*>(site_instance)),
       process_(site_instance->GetProcess()),
       cross_process_frame_connector_(NULL),
       render_frame_proxy_host_(NULL),
       frame_tree_(frame_tree),
       frame_tree_node_(frame_tree_node),
       render_widget_host_(nullptr),
@@ skipping 570 matching lines @@
     render_widget_host_->InitForFrame();
 }
 
 void RenderFrameHostImpl::Init() {
   // TODO(csharrison): Call GetProcess()->ResumeRequestsForFrame(routing_id_)
   // once ResourceDispatcherHostImpl is keyed on render frame routing ids
   // instead of render view routing ids.
 }
 
 void RenderFrameHostImpl::OnAddMessageToConsole(
-    int32 level,
+    int32_t level,
     const base::string16& message,
-    int32 line_no,
+    int32_t line_no,
     const base::string16& source_id) {
   if (delegate_->AddMessageToConsole(level, message, line_no, source_id))
     return;
 
   // Pass through log level only on WebUI pages to limit console spew.
   const bool is_web_ui =
       HasWebUIScheme(delegate_->GetMainFrameLastCommittedURL());
-  const int32 resolved_level = is_web_ui ? level : ::logging::LOG_INFO;
+  const int32_t resolved_level = is_web_ui ? level : ::logging::LOG_INFO;
 
   // LogMessages can be persisted so this shouldn't be logged in incognito mode.
   // This rule is not applied to WebUI pages, because source code of WebUI is a
   // part of Chrome source code, and we want to treat messages from WebUI the
   // same way as we treat log messages from native code.
   if (::logging::GetMinLogLevel() <= resolved_level &&
       (is_web_ui ||
        !GetSiteInstance()->GetBrowserContext()->IsOffTheRecord())) {
     logging::LogMessage("CONSOLE", line_no, resolved_level).stream()
         << "\"" << message << "\", source: " << source_id << " (" << line_no
@@ skipping 535 matching lines @@
   std::map<int, JavaScriptResultCallback>::iterator it =
       javascript_callbacks_.find(id);
   if (it != javascript_callbacks_.end()) {
     it->second.Run(result_value);
     javascript_callbacks_.erase(it);
   } else {
     NOTREACHED() << "Received script response for unknown request";
   }
 }
 
-void RenderFrameHostImpl::OnVisualStateResponse(uint64 id) {
+void RenderFrameHostImpl::OnVisualStateResponse(uint64_t id) {
   auto it = visual_state_callbacks_.find(id);
   if (it != visual_state_callbacks_.end()) {
     it->second.Run(true);
     visual_state_callbacks_.erase(it);
   } else {
     NOTREACHED() << "Received script response for unknown request";
   }
 }
 
 void RenderFrameHostImpl::OnRunJavaScriptMessage(
@@ skipping 27 matching lines @@
     size_t start_offset,
     size_t end_offset) {
   render_view_host_->OnTextSurroundingSelectionResponse(
       content, start_offset, end_offset);
 }
 
 void RenderFrameHostImpl::OnDidAccessInitialDocument() {
   delegate_->DidAccessInitialDocument();
 }
 
-void RenderFrameHostImpl::OnDidChangeOpener(int32 opener_routing_id) {
+void RenderFrameHostImpl::OnDidChangeOpener(int32_t opener_routing_id) {
   frame_tree_node_->render_manager()->DidChangeOpener(opener_routing_id,
                                                       GetSiteInstance());
 }
 
 void RenderFrameHostImpl::OnDidChangeName(const std::string& name) {
   std::string old_name = frame_tree_node()->frame_name();
   frame_tree_node()->SetFrameName(name);
   if (old_name.empty() && !name.empty())
     frame_tree_node_->render_manager()->CreateProxiesForNewNamedFrame();
   delegate_->DidChangeName(this, name);
 }
 
 void RenderFrameHostImpl::OnEnforceStrictMixedContentChecking() {
   frame_tree_node()->SetEnforceStrictMixedContentChecking(true);
 }
 
-void RenderFrameHostImpl::OnDidAssignPageId(int32 page_id) {
+void RenderFrameHostImpl::OnDidAssignPageId(int32_t page_id) {
   // Update the RVH's current page ID so that future IPCs from the renderer
   // correspond to the new page.
   render_view_host_->page_id_ = page_id;
 }
 
 FrameTreeNode* RenderFrameHostImpl::FindAndVerifyChild(
-    int32 child_frame_routing_id,
+    int32_t child_frame_routing_id,
     bad_message::BadMessageReason reason) {
   FrameTreeNode* child = frame_tree_node()->frame_tree()->FindByRoutingID(
       GetProcess()->GetID(), child_frame_routing_id);
   // A race can result in |child| to be nullptr. Avoid killing the renderer in
   // that case.
   if (child && child->parent() != frame_tree_node()) {
     bad_message::ReceivedBadMessage(GetProcess(), reason);
     return nullptr;
   }
   return child;
 }
 
 void RenderFrameHostImpl::OnDidChangeSandboxFlags(
-    int32 frame_routing_id,
+    int32_t frame_routing_id,
     blink::WebSandboxFlags flags) {
   // Ensure that a frame can only update sandbox flags for its immediate
   // children.  If this is not the case, the renderer is considered malicious
   // and is killed.
   FrameTreeNode* child = FindAndVerifyChild(
       frame_routing_id, bad_message::RFH_SANDBOX_FLAGS);
   if (!child)
     return;
 
   child->set_sandbox_flags(flags);
 
   // Notify the RenderFrame if it lives in a different process from its
   // parent. The frame's proxies in other processes also need to learn about
   // the updated sandbox flags, but these notifications are sent later in
   // RenderFrameHostManager::CommitPendingSandboxFlags(), when the frame
   // navigates and the new sandbox flags take effect.
   RenderFrameHost* child_rfh = child->current_frame_host();
   if (child_rfh->GetSiteInstance() != GetSiteInstance()) {
     child_rfh->Send(
         new FrameMsg_DidUpdateSandboxFlags(child_rfh->GetRoutingID(), flags));
   }
 }
 
 void RenderFrameHostImpl::OnDidChangeFrameOwnerProperties(
-    int32 frame_routing_id,
+    int32_t frame_routing_id,
     const blink::WebFrameOwnerProperties& frame_owner_properties) {
   FrameTreeNode* child = FindAndVerifyChild(
       frame_routing_id, bad_message::RFH_OWNER_PROPERTY);
   if (!child)
     return;
 
   child->set_frame_owner_properties(frame_owner_properties);
 
   // Notify the RenderFrame if it lives in a different process from its parent.
   // These properties only affect the RenderFrame and live in its parent
@@ skipping 818 matching lines @@
   if (accessibility_mode & AccessibilityModeFlagPlatform) {
     BrowserAccessibilityManager* manager =
         GetOrCreateBrowserAccessibilityManager();
     if (manager)
       manager->ActivateFindInPageResult(request_id);
   }
 }
 
 void RenderFrameHostImpl::InsertVisualStateCallback(
     const VisualStateCallback& callback) {
-  static uint64 next_id = 1;
-  uint64 key = next_id++;
+  static uint64_t next_id = 1;
+  uint64_t key = next_id++;
   Send(new FrameMsg_VisualStateRequest(routing_id_, key));
   visual_state_callbacks_.insert(std::make_pair(key, callback));
 }
 
 bool RenderFrameHostImpl::IsRenderFrameLive() {
   bool is_live = GetProcess()->HasConnection() && render_frame_created_;
 
   // Sanity check: the RenderView should always be live if the RenderFrame is.
   DCHECK(!is_live || render_view_host_->IsRenderViewLive());
 
@@ skipping 185 matching lines @@
 void RenderFrameHostImpl::AXContentNodeDataToAXNodeData(
     const AXContentNodeData& src,
     ui::AXNodeData* dst) {
   // Copy the common fields.
   *dst = src;
 
   // Map content-specific attributes based on routing IDs or browser plugin
   // instance IDs to generic attributes with global AXTreeIDs.
   for (auto iter : src.content_int_attributes) {
     AXContentIntAttribute attr = iter.first;
-    int32 value = iter.second;
+    int32_t value = iter.second;
     switch (attr) {
       case AX_CONTENT_ATTR_CHILD_ROUTING_ID:
         dst->int_attributes.push_back(std::make_pair(
             ui::AX_ATTR_CHILD_TREE_ID, RoutingIDToAXTreeID(value)));
         break;
       case AX_CONTENT_ATTR_CHILD_BROWSER_PLUGIN_INSTANCE_ID:
         dst->int_attributes.push_back(std::make_pair(
             ui::AX_ATTR_CHILD_TREE_ID,
             BrowserPluginInstanceIDToAXTreeID(value)));
         break;
@@ skipping 11 matching lines @@
   *dst = src;
 
   if (src.routing_id != -1)
     dst->tree_id = RoutingIDToAXTreeID(src.routing_id);
 
   if (src.parent_routing_id != -1)
     dst->parent_tree_id = RoutingIDToAXTreeID(src.parent_routing_id);
 }
 
 }  // namespace content