Remove kuint32max.

ui/base/clipboard/clipboard_aurax11.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_aurax11.h"
 
+#include <stdint.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/Xatom.h>
+
+#include <limits>
 #include <list>
 #include <set>
 
-#include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.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"
@@ skipping 35 matching lines @@
   NULL
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Uses the XFixes API to provide sequence numbers for GetSequenceNumber().
 class SelectionChangeObserver : public ui::PlatformEventObserver {
  public:
   static SelectionChangeObserver* GetInstance();
 
-  uint64 clipboard_sequence_number() const {
+  uint64_t clipboard_sequence_number() const {
     return clipboard_sequence_number_;
   }
-  uint64 primary_sequence_number() const { return primary_sequence_number_; }
+  uint64_t primary_sequence_number() const { return primary_sequence_number_; }
 
  private:
   friend struct base::DefaultSingletonTraits<SelectionChangeObserver>;
 
   SelectionChangeObserver();
   ~SelectionChangeObserver() override;
 
   // ui::PlatformEventObserver:
   void WillProcessEvent(const ui::PlatformEvent& event) override;
   void DidProcessEvent(const ui::PlatformEvent& event) override {}
 
   int event_base_;
   Atom clipboard_atom_;
-  uint64 clipboard_sequence_number_;
-  uint64 primary_sequence_number_;
+  uint64_t clipboard_sequence_number_;
+  uint64_t primary_sequence_number_;
 
   DISALLOW_COPY_AND_ASSIGN(SelectionChangeObserver);
 };
 
 SelectionChangeObserver::SelectionChangeObserver()
     : event_base_(-1),
       clipboard_atom_(None),
       clipboard_sequence_number_(0),
       primary_sequence_number_(0) {
   int ignored;
@@ skipping 566 matching lines @@
 ClipboardAuraX11::ClipboardAuraX11() : aurax11_details_(new AuraX11Details) {
   DCHECK(CalledOnValidThread());
 }
 
 ClipboardAuraX11::~ClipboardAuraX11() {
   DCHECK(CalledOnValidThread());
 
   aurax11_details_->StoreCopyPasteDataAndWait();
 }
 
-uint64 ClipboardAuraX11::GetSequenceNumber(ClipboardType type) const {
+uint64_t ClipboardAuraX11::GetSequenceNumber(ClipboardType type) const {
   DCHECK(CalledOnValidThread());
   if (type == CLIPBOARD_TYPE_COPY_PASTE)
     return SelectionChangeObserver::GetInstance()->clipboard_sequence_number();
   else
     return SelectionChangeObserver::GetInstance()->primary_sequence_number();
 }
 
 bool ClipboardAuraX11::IsFormatAvailable(const FormatType& format,
                                          ClipboardType type) const {
   DCHECK(CalledOnValidThread());
@@ skipping 62 matching lines @@
       type, aurax11_details_->GetTextAtoms()));
   if (data.IsValid())
     result->assign(data.GetText());
 }
 
 // TODO(estade): handle different charsets.
 // TODO(port): set *src_url.
 void ClipboardAuraX11::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());
   markup->clear();
   if (src_url)
     src_url->clear();
   *fragment_start = 0;
   *fragment_end = 0;
 
   SelectionData data(aurax11_details_->RequestAndWaitForTypes(
       type, aurax11_details_->GetAtomsForFormat(GetHtmlFormatType())));
   if (data.IsValid()) {
     *markup = data.GetHtml();
 
     *fragment_start = 0;
-    DCHECK(markup->length() <= kuint32max);
-    *fragment_end = static_cast<uint32>(markup->length());
+    DCHECK(markup->length() <= std::numeric_limits<uint32_t>::max());
+    *fragment_end = static_cast<uint32_t>(markup->length());
   }
 }
 
 void ClipboardAuraX11::ReadRTF(ClipboardType type, std::string* result) const {
   DCHECK(CalledOnValidThread());
 
   SelectionData data(aurax11_details_->RequestAndWaitForTypes(
       type, aurax11_details_->GetAtomsForFormat(GetRtfFormatType())));
   if (data.IsValid())
     data.AssignTo(result);
@@ skipping 147 matching lines @@
   if (format.Equals(GetBitmapFormatType()))
     return;
 
   std::vector<unsigned char> bytes(data_data, data_data + data_len);
   scoped_refptr<base::RefCountedMemory> mem(
       base::RefCountedBytes::TakeVector(&bytes));
   aurax11_details_->InsertMapping(format.ToString(), mem);
 }
 
 }  // namespace ui