Switch to standard integer types in content/browser/.

content/browser/frame_host/render_frame_host_manager.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_manager.h"
 
+#include <stddef.h>
+
 #include <algorithm>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/devtools/render_frame_devtools_agent_host.h"
 #include "content/browser/frame_host/cross_site_transferring_request.h"
@@ skipping 65 matching lines @@
   return true;
 }
 
 }  // namespace
 
 // A helper class to hold all frame proxies and register as a
 // RenderProcessHostObserver for them.
 class RenderFrameHostManager::RenderFrameProxyHostMap
     : public RenderProcessHostObserver {
  public:
-  using MapType = base::hash_map<int32, RenderFrameProxyHost*>;
+  using MapType = base::hash_map<int32_t, RenderFrameProxyHost*>;
 
   RenderFrameProxyHostMap(RenderFrameHostManager* manager);
   ~RenderFrameProxyHostMap() override;
 
   // Read-only access to the underlying map of site instance ID to
   // RenderFrameProxyHosts.
   MapType::const_iterator begin() const { return map_.begin(); }
   MapType::const_iterator end() const { return map_.end(); }
   bool empty() const { return map_.empty(); }
 
   // Returns the proxy with the specified ID, or nullptr if there is no such
   // one.
-  RenderFrameProxyHost* Get(int32 id);
+  RenderFrameProxyHost* Get(int32_t id);
 
   // Adds the specified proxy with the specified ID. It is an error (and fatal)
   // to add more than one proxy with the specified ID.
-  void Add(int32 id, scoped_ptr<RenderFrameProxyHost> proxy);
+  void Add(int32_t id, scoped_ptr<RenderFrameProxyHost> proxy);
 
   // Removes the proxy with the specified site instance ID.
-  void Remove(int32 id);
+  void Remove(int32_t id);
 
   // Removes all proxies.
   void Clear();
 
   // RenderProcessHostObserver implementation.
   void RenderProcessWillExit(RenderProcessHost* host) override;
   void RenderProcessExited(RenderProcessHost* host,
                            base::TerminationStatus status,
                            int exit_code) override;
 
  private:
   RenderFrameHostManager* manager_;
   MapType map_;
 };
 
 RenderFrameHostManager::RenderFrameProxyHostMap::RenderFrameProxyHostMap(
     RenderFrameHostManager* manager)
     : manager_(manager) {}
 
 RenderFrameHostManager::RenderFrameProxyHostMap::~RenderFrameProxyHostMap() {
   Clear();
 }
 
 RenderFrameProxyHost* RenderFrameHostManager::RenderFrameProxyHostMap::Get(
-    int32 id) {
+    int32_t id) {
   auto it = map_.find(id);
   if (it != map_.end())
     return it->second;
   return nullptr;
 }
 
 void RenderFrameHostManager::RenderFrameProxyHostMap::Add(
-    int32 id,
+    int32_t id,
     scoped_ptr<RenderFrameProxyHost> proxy) {
   CHECK_EQ(0u, map_.count(id)) << "Inserting a duplicate item.";
 
   // If this is the first proxy that has this process host, observe the
   // process host.
   RenderProcessHost* host = proxy->GetProcess();
   size_t count =
       std::count_if(begin(), end(), [host](MapType::value_type item) {
         return item.second->GetProcess() == host;
       });
   if (count == 0)
     host->AddObserver(this);
 
   map_[id] = proxy.release();
 }
 
-void RenderFrameHostManager::RenderFrameProxyHostMap::Remove(int32 id) {
+void RenderFrameHostManager::RenderFrameProxyHostMap::Remove(int32_t id) {
   auto it = map_.find(id);
   if (it == map_.end())
     return;
 
   // If this is the last proxy that has this process host, stop observing the
   // process host.
   RenderProcessHost* host = it->second->GetProcess();
   size_t count =
       std::count_if(begin(), end(), [host](MapType::value_type item) {
         return item.second->GetProcess() == host;
@@ skipping 79 matching lines @@
   // RenderFrameHost, since the CrossProcessFrameConnector (owned by
   // RenderFrameProxyHost) points to the RenderWidgetHostView associated with
   // the current RenderFrameHost and uses it during its destructor.
   ResetProxyHosts();
 
   // We should always have a current RenderFrameHost except in some tests.
   SetRenderFrameHost(scoped_ptr<RenderFrameHostImpl>());
 }
 
 void RenderFrameHostManager::Init(SiteInstance* site_instance,
-                                  int32 view_routing_id,
-                                  int32 frame_routing_id,
-                                  int32 widget_routing_id) {
+                                  int32_t view_routing_id,
+                                  int32_t frame_routing_id,
+                                  int32_t widget_routing_id) {
   DCHECK(site_instance);
   // TODO(avi): While RenderViewHostImpl is-a RenderWidgetHostImpl, this must
   // hold true to avoid having two RenderWidgetHosts for the top-level frame.
   // https://crbug.com/545684
   DCHECK(!frame_tree_node_->IsMainFrame() ||
          view_routing_id == widget_routing_id);
   int flags = delegate_->IsHidden() ? CREATE_RF_HIDDEN : 0;
   SetRenderFrameHost(CreateRenderFrameHost(site_instance, view_routing_id,
                                            frame_routing_id, widget_routing_id,
                                            flags));
@@ skipping 555 matching lines @@
   // TODO(creis): Handle modal dialogs in subframe processes.
   old_render_frame_host->render_view_host()->SuppressDialogsUntilSwapOut();
 
   // Now close any modal dialogs that would prevent us from swapping out.  This
   // must be done separately from SwapOut, so that the PageGroupLoadDeferrer is
   // no longer on the stack when we send the SwapOut message.
   delegate_->CancelModalDialogsForRenderManager();
 
   // If the old RFH is not live, just return as there is no further work to do.
   // It will be deleted and there will be no proxy created.
-  int32 old_site_instance_id =
+  int32_t old_site_instance_id =
       old_render_frame_host->GetSiteInstance()->GetId();
   if (!old_render_frame_host->IsRenderFrameLive()) {
     ShutdownProxiesIfLastActiveFrameInSiteInstance(old_render_frame_host.get());
     return;
   }
 
   // If there are no active frames besides this one, we can delete the old
   // RenderFrameHost once it runs its unload handler, without replacing it with
   // a proxy.
   size_t active_frame_count =
@@ skipping 344 matching lines @@
     BrowserContext* browser_context,
     GURL dest_url,
     bool related_to_current)
     : existing_site_instance(nullptr),
       new_is_related_to_current(related_to_current) {
   new_site_url = SiteInstance::GetSiteForURL(browser_context, dest_url);
 }
 
 // static
 bool RenderFrameHostManager::ClearProxiesInSiteInstance(
-    int32 site_instance_id,
+    int32_t site_instance_id,
     FrameTreeNode* node) {
   RenderFrameProxyHost* proxy =
       node->render_manager()->proxy_hosts_->Get(site_instance_id);
   if (proxy) {
     // Delete the proxy.  If it is for a main frame (and thus the RFH is stored
     // in the proxy) and it was still pending swap out, move the RFH to the
     // pending deletion list first.
     if (node->IsMainFrame() &&
         proxy->render_frame_host() &&
         proxy->render_frame_host()->rfh_state() ==
             RenderFrameHostImpl::STATE_PENDING_SWAP_OUT) {
       DCHECK(!SiteIsolationPolicy::IsSwappedOutStateForbidden());
       scoped_ptr<RenderFrameHostImpl> swapped_out_rfh =
           proxy->PassFrameHostOwnership();
       node->render_manager()->MoveToPendingDeleteHosts(swapped_out_rfh.Pass());
     }
     node->render_manager()->proxy_hosts_->Remove(site_instance_id);
   }
 
   return true;
 }
 
 // static.
-bool RenderFrameHostManager::ResetProxiesInSiteInstance(int32 site_instance_id,
-                                                        FrameTreeNode* node) {
+bool RenderFrameHostManager::ResetProxiesInSiteInstance(
+    int32_t site_instance_id,
+    FrameTreeNode* node) {
   RenderFrameProxyHost* proxy =
       node->render_manager()->proxy_hosts_->Get(site_instance_id);
   if (proxy)
     proxy->set_render_frame_proxy_created(false);
 
   return true;
 }
 
 bool RenderFrameHostManager::ShouldTransitionCrossSite() {
   // The logic below is weaker than "are all sites isolated" -- it asks instead,
@@ skipping 484 matching lines @@
   for (FrameTreeNode* ancestor = opener->parent(); ancestor;
        ancestor = ancestor->parent()) {
     RenderFrameHostImpl* ancestor_rfh = ancestor->current_frame_host();
     if (ancestor_rfh->GetSiteInstance() != current_instance)
       CreateRenderFrameProxy(ancestor_rfh->GetSiteInstance());
   }
 }
 
 scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::CreateRenderFrameHost(
     SiteInstance* site_instance,
-    int32 view_routing_id,
-    int32 frame_routing_id,
-    int32 widget_routing_id,
+    int32_t view_routing_id,
+    int32_t frame_routing_id,
+    int32_t widget_routing_id,
     int flags) {
   if (frame_routing_id == MSG_ROUTING_NONE)
     frame_routing_id = site_instance->GetProcess()->GetNextRoutingID();
 
   bool swapped_out = !!(flags & CREATE_RF_SWAPPED_OUT);
   bool hidden = !!(flags & CREATE_RF_HIDDEN);
 
   // Create a RVH for main frames, or find the existing one for subframes.
   FrameTree* frame_tree = frame_tree_node_->frame_tree();
   RenderViewHostImpl* render_view_host = nullptr;
@@ skipping 97 matching lines @@
       // RenderWidgetHostView, we need to create one if this is the main frame.
       if (render_view_host->IsRenderViewLive() &&
           !render_view_host->GetWidget()->GetView() &&
           frame_tree_node_->IsMainFrame()) {
         delegate_->CreateRenderWidgetHostViewForRenderManager(render_view_host);
       }
     }
   } else {
     // Create a new RenderFrameHost if we don't find an existing one.
 
-    int32 widget_routing_id = MSG_ROUTING_NONE;
+    int32_t widget_routing_id = MSG_ROUTING_NONE;
 
     // A RenderFrame in a different process from its parent RenderFrame
     // requires a RenderWidget for input/layout/painting.
     if (frame_tree_node_->parent() &&
         frame_tree_node_->parent()->current_frame_host()->GetSiteInstance() !=
             instance) {
       CHECK(SiteIsolationPolicy::AreCrossProcessFramesPossible());
       widget_routing_id = instance->GetProcess()->GetNextRoutingID();
     }
 
@@ skipping 406 matching lines @@
   if (!render_frame_host)
     return;
   if (!RenderFrameHostImpl::IsRFHStateActive(render_frame_host->rfh_state()))
     return;
   if (render_frame_host->GetSiteInstance()->active_frame_count() > 1U)
     return;
 
   // After |render_frame_host| goes away, there will be no active frames left in
   // its SiteInstance, so we can delete all proxies created in that SiteInstance
   // on behalf of frames anywhere in the BrowsingInstance.
-  int32 site_instance_id = render_frame_host->GetSiteInstance()->GetId();
+  int32_t site_instance_id = render_frame_host->GetSiteInstance()->GetId();
 
   // First remove any proxies for this SiteInstance from our own list.
   ClearProxiesInSiteInstance(site_instance_id, frame_tree_node_);
 
   // Use the safe RenderWidgetHost iterator for now to find all RenderViewHosts
   // in the SiteInstance, then tell their respective FrameTrees to remove all
   // RenderFrameProxyHosts corresponding to them.
   // TODO(creis): Replace this with a RenderFrameHostIterator that protects
   // against use-after-frees if a later element is deleted before getting to it.
   scoped_ptr<RenderWidgetHostIterator> widgets(
@@ skipping 386 matching lines @@
 int RenderFrameHostManager::GetOpenerRoutingID(SiteInstance* instance) {
   if (!frame_tree_node_->opener())
     return MSG_ROUTING_NONE;
 
   return frame_tree_node_->opener()
       ->render_manager()
       ->GetRoutingIdForSiteInstance(instance);
 }
 
 }  // namespace content