Switch to standard integer types in content/renderer/.

content/renderer/render_frame_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/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/debug/asan_invalid_access.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/files/file.h"
 #include "base/i18n/char_iterator.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "build/build_config.h"
 #include "cc/base/switches.h"
 #include "components/scheduler/renderer/renderer_scheduler.h"
 #include "content/child/appcache/appcache_dispatcher.h"
 #include "content/child/permissions/permission_dispatcher.h"
 #include "content/child/plugin_messages.h"
 #include "content/child/quota_dispatcher.h"
 #include "content/child/request_extra_data.h"
 #include "content/child/service_worker/service_worker_handle_reference.h"
 #include "content/child/service_worker/service_worker_network_provider.h"
 #include "content/child/service_worker/service_worker_provider_context.h"
@@ skipping 244 matching lines @@
 
 const size_t kExtraCharsBeforeAndAfterSelection = 100;
 
 typedef std::map<int, RenderFrameImpl*> RoutingIDFrameMap;
 static base::LazyInstance<RoutingIDFrameMap> g_routing_id_frame_map =
     LAZY_INSTANCE_INITIALIZER;
 
 typedef std::map<blink::WebFrame*, RenderFrameImpl*> FrameMap;
 base::LazyInstance<FrameMap> g_frame_map = LAZY_INSTANCE_INITIALIZER;
 
-int64 ExtractPostId(const WebHistoryItem& item) {
+int64_t ExtractPostId(const WebHistoryItem& item) {
   if (item.isNull() || item.httpBody().isNull())
     return -1;
 
   return item.httpBody().identifier();
 }
 
 WebURLResponseExtraDataImpl* GetExtraDataFromResponse(
     const WebURLResponse& response) {
   return static_cast<WebURLResponseExtraDataImpl*>(response.extraData());
 }
@@ skipping 305 matching lines @@
           main_resource_ssl_status.cert_status != ssl_status.cert_status ||
           main_resource_ssl_status.security_bits != ssl_status.security_bits ||
           main_resource_ssl_status.connection_status !=
               ssl_status.connection_status);
 }
 
 }  // namespace
 
 // static
 RenderFrameImpl* RenderFrameImpl::Create(RenderViewImpl* render_view,
-                                         int32 routing_id) {
+                                         int32_t routing_id) {
   DCHECK(routing_id != MSG_ROUTING_NONE);
   CreateParams params(render_view, routing_id);
 
   if (g_create_render_frame_impl)
     return g_create_render_frame_impl(params);
   else
     return new RenderFrameImpl(params);
 }
 
 // static
@@ skipping 484 matching lines @@
   const base::string16& last_text = text.empty() ? pepper_composition_text_
                                                  : text;
 
   // last_text is empty only when both text and pepper_composition_text_ is.
   // Ignore it.
   if (last_text.empty())
     return;
 
   if (!IsPepperAcceptingCompositionEvents()) {
     base::i18n::UTF16CharIterator iterator(&last_text);
-    int32 i = 0;
+    int32_t i = 0;
     while (iterator.Advance()) {
       blink::WebKeyboardEvent char_event;
       char_event.type = blink::WebInputEvent::Char;
       char_event.timeStampSeconds = base::Time::Now().ToDoubleT();
       char_event.modifiers = 0;
       char_event.windowsKeyCode = last_text[i];
       char_event.nativeKeyCode = last_text[i];
 
-      const int32 char_start = i;
+      const int32_t char_start = i;
       for (; i < iterator.array_pos(); ++i) {
         char_event.text[i - char_start] = last_text[i];
         char_event.unmodifiedText[i - char_start] = last_text[i];
       }
 
       if (GetRenderWidget()->webwidget())
         GetRenderWidget()->webwidget()->handleInputEvent(char_event);
     }
   } else {
     // Mimics the order of events sent by WebKit.
@@ skipping 620 matching lines @@
           converter.FromV8Value(result, context));
       list.Set(0, result_value ? result_value.Pass()
                                : base::Value::CreateNullValue());
     } else {
       list.Set(0, base::Value::CreateNullValue());
     }
     Send(new FrameHostMsg_JavaScriptExecuteResponse(routing_id_, id, list));
   }
 }
 
-void RenderFrameImpl::OnVisualStateRequest(uint64 id) {
+void RenderFrameImpl::OnVisualStateRequest(uint64_t id) {
   GetRenderWidget()->QueueMessage(
       new FrameHostMsg_VisualStateResponse(routing_id_, id),
       MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE);
 }
 
 void RenderFrameImpl::OnSetEditableSelectionOffsets(int start, int end) {
   base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
   if (!GetRenderWidget()->ShouldHandleImeEvent())
     return;
   ImeEventGuard guard(GetRenderWidget());
@@ skipping 847 matching lines @@
       log_severity = logging::LOG_WARNING;
       break;
     case blink::WebConsoleMessage::LevelError:
       log_severity = logging::LOG_ERROR;
       break;
     default:
       log_severity = logging::LOG_VERBOSE;
   }
 
   if (shouldReportDetailedMessageForSource(source_name)) {
-    FOR_EACH_OBSERVER(
-        RenderFrameObserver, observers_,
-        DetailedConsoleMessageAdded(message.text,
-                                    source_name,
-                                    stack_trace,
-                                    source_line,
-                                    static_cast<int32>(log_severity)));
+    FOR_EACH_OBSERVER(RenderFrameObserver, observers_,
+                      DetailedConsoleMessageAdded(
+                          message.text, source_name, stack_trace, source_line,
+                          static_cast<int32_t>(log_severity)));
   }
 
-  Send(new FrameHostMsg_AddMessageToConsole(routing_id_,
-                                            static_cast<int32>(log_severity),
-                                            message.text,
-                                            static_cast<int32>(source_line),
-                                            source_name));
+  Send(new FrameHostMsg_AddMessageToConsole(
+      routing_id_, static_cast<int32_t>(log_severity), message.text,
+      static_cast<int32_t>(source_line), source_name));
 }
 
 void RenderFrameImpl::loadURLExternally(const blink::WebURLRequest& request,
                                         blink::WebNavigationPolicy policy,
                                         const blink::WebString& suggested_name,
                                         bool should_replace_current_entry) {
   Referrer referrer(RenderViewImpl::GetReferrerFromRequest(frame_, request));
   if (policy == blink::WebNavigationPolicyDownload) {
     render_view_->Send(new ViewHostMsg_DownloadUrl(render_view_->GetRoutingID(),
                                                    GetRoutingID(),
@@ skipping 1636 matching lines @@
       !response.isMultipartPayload() && (response.httpStatusCode() != 404);
 
   params.searchable_form_url = internal_data->searchable_form_url();
   params.searchable_form_encoding = internal_data->searchable_form_encoding();
 
   params.gesture = render_view_->navigation_gesture_;
   render_view_->navigation_gesture_ = NavigationGestureUnknown;
 
   // Make navigation state a part of the DidCommitProvisionalLoad message so
   // that committed entry has it at all times.
-  int64 post_id = -1;
+  int64_t post_id = -1;
   if (!SiteIsolationPolicy::UseSubframeNavigationEntries()) {
     HistoryEntry* entry = render_view_->history_controller()->GetCurrentEntry();
     if (entry) {
       params.page_state = HistoryEntryToPageState(entry);
       post_id = ExtractPostId(entry->root());
     } else {
       params.page_state = PageState::CreateFromURL(request.url());
     }
   } else {
     // In --site-per-process, just send a single HistoryItem for this frame,
@@ skipping 1321 matching lines @@
       media::ConvertToSwitchOutputDeviceCB(web_callbacks);
   scoped_refptr<media::AudioOutputDevice> device =
       AudioDeviceFactory::NewOutputDevice(routing_id_, 0, sink_id.utf8(),
                                           security_origin);
   media::OutputDeviceStatus status = device->GetDeviceStatus();
   device->Stop();
   callback.Run(status);
 }
 
 }  // namespace content