Switch to standard integer types in content/renderer/.

content/renderer/render_widget.h

 // 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.
 
 #ifndef CONTENT_RENDERER_RENDER_WIDGET_H_
 #define CONTENT_RENDERER_RENDER_WIDGET_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <deque>
 #include <map>
 
-#include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
+#include "build/build_config.h"
 #include "content/common/content_export.h"
 #include "content/common/cursors/webcursor.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/input/synthetic_gesture_params.h"
 #include "content/renderer/input/render_widget_input_handler.h"
 #include "content/renderer/input/render_widget_input_handler_delegate.h"
 #include "content/renderer/message_delivery_policy.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
 #include "third_party/WebKit/public/platform/WebDisplayMode.h"
@@ skipping 69 matching lines @@
 // - Widgets for frames (for out-of-process iframe support)
 class CONTENT_EXPORT RenderWidget
     : public IPC::Listener,
       public IPC::Sender,
       NON_EXPORTED_BASE(virtual public blink::WebWidgetClient),
       public RenderWidgetInputHandlerDelegate,
       public base::RefCounted<RenderWidget> {
  public:
   // Creates a new RenderWidget.  The opener_id is the routing ID of the
   // RenderView that this widget lives inside.
-  static RenderWidget* Create(int32 opener_id,
+  static RenderWidget* Create(int32_t opener_id,
                               CompositorDependencies* compositor_deps,
                               blink::WebPopupType popup_type,
                               const blink::WebScreenInfo& screen_info);
 
   // Creates a new RenderWidget that will be attached to a RenderFrame.
   static RenderWidget* CreateForFrame(int routing_id,
                                       bool hidden,
                                       const blink::WebScreenInfo& screen_info,
                                       CompositorDependencies* compositor_deps,
                                       blink::WebLocalFrame* frame);
 
   // Closes a RenderWidget that was created by |CreateForFrame|.
   // TODO(avi): De-virtualize this once RenderViewImpl has-a RenderWidget.
   // https://crbug.com/545684
   virtual void CloseForFrame();
 
-  int32 routing_id() const { return routing_id_; }
+  int32_t routing_id() const { return routing_id_; }
   CompositorDependencies* compositor_deps() const { return compositor_deps_; }
   blink::WebWidget* webwidget() const { return webwidget_; }
   gfx::Size size() const { return size_; }
   bool is_fullscreen_granted() const { return is_fullscreen_granted_; }
   blink::WebDisplayMode display_mode() const { return display_mode_; }
   bool is_hidden() const { return is_hidden_; }
   // Temporary for debugging purposes...
   bool closing() const { return closing_; }
   bool is_swapped_out() { return is_swapped_out_; }
   bool for_oopif() { return for_oopif_; }
@@ skipping 221 matching lines @@
 
   ~RenderWidget() override;
 
   static blink::WebWidget* CreateWebFrameWidget(RenderWidget* render_widget,
                                                 blink::WebLocalFrame* frame);
 
   // Creates a WebWidget based on the popup type.
   static blink::WebWidget* CreateWebWidget(RenderWidget* render_widget);
 
   // Initializes this view with the given opener.
-  bool Init(int32 opener_id);
+  bool Init(int32_t opener_id);
 
   // Called by Init and subclasses to perform initialization.
-  bool DoInit(int32 opener_id,
+  bool DoInit(int32_t opener_id,
               blink::WebWidget* web_widget,
               IPC::SyncMessage* create_widget_message);
 
   // Sets whether this RenderWidget has been swapped out to be displayed by
   // a RenderWidget in a different process.  If so, no new IPC messages will be
   // sent (only ACKs) and the process is free to exit when there are no other
   // active RenderWidgets.
   void SetSwappedOut(bool is_swapped_out);
 
   // Allows the process to exit once the unload handler has finished, if there
@@ skipping 35 matching lines @@
   void OnClose();
   void OnCreatingNewAck();
   virtual void OnResize(const ViewMsg_Resize_Params& params);
   void OnEnableDeviceEmulation(const blink::WebDeviceEmulationParams& params);
   void OnDisableDeviceEmulation();
   void OnColorProfile(const std::vector<char>& color_profile);
   void OnChangeResizeRect(const gfx::Rect& resizer_rect);
   virtual void OnWasHidden();
   virtual void OnWasShown(bool needs_repainting,
                           const ui::LatencyInfo& latency_info);
-  void OnCreateVideoAck(int32 video_id);
-  void OnUpdateVideoAck(int32 video_id);
+  void OnCreateVideoAck(int32_t video_id);
+  void OnUpdateVideoAck(int32_t video_id);
   void OnRequestMoveAck();
   virtual void OnImeSetComposition(
       const base::string16& text,
       const std::vector<blink::WebCompositionUnderline>& underlines,
       int selection_start,
       int selection_end);
   virtual void OnImeConfirmComposition(const base::string16& text,
                                        const gfx::Range& replacement_range,
                                        bool keep_selection);
   // Called when the device scale factor is changed, or the layer tree is
@@ skipping 102 matching lines @@
   // Called when value of focused text field gets dirty, e.g. value is modified
   // by script, not by user input.
   void didUpdateTextOfFocusedElementByNonUserInput() override;
 
   // Creates a 3D context associated with this view.
   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> CreateGraphicsContext3D(
       bool compositor);
 
   // Routing ID that allows us to communicate to the parent browser process
   // RenderWidgetHost. When MSG_ROUTING_NONE, no messages may be sent.
-  int32 routing_id_;
+  int32_t routing_id_;
 
   // Dependencies for initializing a compositor, including flags for optional
   // features.
   CompositorDependencies* const compositor_deps_;
 
   // We are responsible for destroying this object via its Close method.
   // May be NULL when the window is closing.
   blink::WebWidget* webwidget_;
 
   // This is lazily constructed and must not outlive webwidget_.
   scoped_ptr<RenderWidgetCompositor> compositor_;
 
   // Set to the ID of the view that initiated creating this view, if any. When
   // the view was initiated by the browser (the common case), this will be
   // MSG_ROUTING_NONE. This is used in determining ownership when opening
   // child tabs. See RenderWidget::createWebViewWithRequest.
   //
   // This ID may refer to an invalid view if that view is closed before this
   // view is.
-  int32 opener_id_;
+  int32_t opener_id_;
 
   // The rect where this view should be initially shown.
   gfx::Rect initial_rect_;
 
   // We store the current cursor object so we can avoid spamming SetCursor
   // messages.
   WebCursor current_cursor_;
 
   // The size of the RenderWidget.
   gfx::Size size_;
@@ skipping 117 matching lines @@
 
   // The device color profile on supported platforms.
   std::vector<char> device_color_profile_;
 
   // State associated with synthetic gestures. Synthetic gestures are processed
   // in-order, so a queue is sufficient to identify the correct state for a
   // completed gesture.
   std::queue<SyntheticGestureCompletionCallback>
       pending_synthetic_gesture_callbacks_;
 
-  uint32 next_output_surface_id_;
+  uint32_t next_output_surface_id_;
 
 #if defined(OS_ANDROID)
   // Indicates value in the focused text field is in dirty state, i.e. modified
   // by script etc., not by user input.
   bool text_field_is_dirty_;
 
   // Stores the history of text input infos from the last ACK'ed one from the
   // current one. The size is the number of pending ACKs plus one, since we
   // intentionally keep the last ack'd value to know what the browser is
   // currently aware of.
@@ skipping 28 matching lines @@
 
   scoped_ptr<scheduler::RenderWidgetSchedulingState>
       render_widget_scheduling_state_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidget);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_RENDER_WIDGET_H_