Remove kuint32max.

ui/base/clipboard/clipboard_aura.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 "ui/base/clipboard/clipboard_aura.h"
 
+#include <stdint.h>
+
+#include <limits>
 #include <list>
 
-#include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/clipboard/custom_data_helper.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace ui {
@@ skipping 183 matching lines @@
       *result = data->text();
     else if (HasFormat(HTML))
       *result = data->markup_data();
     else if (HasFormat(BOOKMARK))
       *result = data->bookmark_url();
   }
 
   // Reads HTML from the data at the top of clipboard stack.
   void ReadHTML(base::string16* markup,
                 std::string* src_url,
-                uint32* fragment_start,
-                uint32* fragment_end) const {
+                uint32_t* fragment_start,
+                uint32_t* fragment_end) const {
     markup->clear();
     if (src_url)
       src_url->clear();
     *fragment_start = 0;
     *fragment_end = 0;
 
     if (!HasFormat(HTML))
       return;
 
     const ClipboardData* data = GetData();
     *markup = base::UTF8ToUTF16(data->markup_data());
     *src_url = data->url();
 
     *fragment_start = 0;
-    DCHECK_LE(markup->length(), kuint32max);
-    *fragment_end = static_cast<uint32>(markup->length());
+    DCHECK_LE(markup->length(), std::numeric_limits<uint32_t>::max());
+    *fragment_end = static_cast<uint32_t>(markup->length());
   }
 
   // Reads RTF from the data at the top of clipboard stack.
   void ReadRTF(std::string* result) const {
     result->clear();
     const ClipboardData* data = GetData();
     if (!HasFormat(RTF))
       return;
 
     *result = data->rtf_data();
@@ skipping 280 matching lines @@
   DCHECK(CalledOnValidThread());
   // Make sure clipboard is created.
   GetClipboard();
 }
 
 ClipboardAura::~ClipboardAura() {
   DCHECK(CalledOnValidThread());
   DeleteClipboard();
 }
 
-uint64 ClipboardAura::GetSequenceNumber(ClipboardType type) const {
+uint64_t ClipboardAura::GetSequenceNumber(ClipboardType type) const {
   DCHECK(CalledOnValidThread());
   return GetClipboard()->sequence_number();
 }
 
 bool ClipboardAura::IsFormatAvailable(const FormatType& format,
                                       ClipboardType type) const {
   DCHECK(CalledOnValidThread());
   DCHECK(IsSupportedClipboardType(type));
   AuraClipboard* clipboard = GetClipboard();
   if (GetPlainTextFormatType().Equals(format) ||
@@ skipping 56 matching lines @@
 
 void ClipboardAura::ReadAsciiText(ClipboardType type,
                                   std::string* result) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadAsciiText(result);
 }
 
 void ClipboardAura::ReadHTML(ClipboardType type,
                              base::string16* markup,
                              std::string* src_url,
-                             uint32* fragment_start,
-                             uint32* fragment_end) const {
+                             uint32_t* fragment_start,
+                             uint32_t* fragment_end) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadHTML(markup, src_url, fragment_start, fragment_end);
 }
 
 void ClipboardAura::ReadRTF(ClipboardType type, std::string* result) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadRTF(result);
 }
 
 SkBitmap ClipboardAura::ReadImage(ClipboardType type) const {
@@ skipping 60 matching lines @@
   ClipboardDataBuilder::WriteBitmap(bitmap);
 }
 
 void ClipboardAura::WriteData(const FormatType& format,
                               const char* data_data,
                               size_t data_len) {
   ClipboardDataBuilder::WriteData(format.ToString(), data_data, data_len);
 }
 
 }  // namespace ui