Remove kint32min.

chrome/renderer/instant_restricted_id_cache_unittest.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 <stdint.h>
+
+#include <limits>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "chrome/renderer/instant_restricted_id_cache.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 struct TestData {
@@ skipping 177 matching lines @@
 }
 
 TEST_F(InstantRestrictedIDCacheTest, CrazyIDGeneration) {
   InstantRestrictedIDCache<TestData> cache(4);
   EXPECT_EQ(0u, cache.cache_.size());
   EXPECT_EQ(0, cache.last_restricted_id_);
 
   // Check first addition.
   std::vector<ItemIDPair> input1;
   input1.push_back(std::make_pair(0, TestData("A")));
-  input1.push_back(std::make_pair(kint32max, TestData("B")));
+  input1.push_back(
+      std::make_pair(std::numeric_limits<int32_t>::max(), TestData("B")));
   input1.push_back(std::make_pair(-100, TestData("C")));
   cache.AddItemsWithRestrictedID(input1);
   EXPECT_EQ(3u, cache.cache_.size());
-  EXPECT_EQ(kint32max, cache.last_restricted_id_);
+  EXPECT_EQ(std::numeric_limits<int32_t>::max(), cache.last_restricted_id_);
 
   std::vector<ItemIDPair> output;
   cache.GetCurrentItems(&output);
   EXPECT_EQ(3u, output.size());
   for (int i = 0; i < 3; ++i) {
     EXPECT_EQ(input1[i].first, output[i].first);
     EXPECT_EQ(input1[i].second, output[i].second);
   }
 
   TestData t;
   EXPECT_FALSE(cache.GetItemWithRestrictedID(1, &t));
-  EXPECT_TRUE(cache.GetItemWithRestrictedID(kint32max, &t));
+  EXPECT_TRUE(
+      cache.GetItemWithRestrictedID(std::numeric_limits<int32_t>::max(), &t));
   EXPECT_EQ(input1[1].second, t);
   EXPECT_TRUE(cache.GetItemWithRestrictedID(-100, &t));
   EXPECT_EQ(input1[2].second, t);
 
   // Add more items, one with same rid, no overflow.
   std::vector<ItemIDPair> input2;
-  input2.push_back(std::make_pair(kint32min, TestData("D")));
+  input2.push_back(
+      std::make_pair(std::numeric_limits<int32_t>::min(), TestData("D")));
   input2.push_back(std::make_pair(7, TestData("E")));
   cache.AddItemsWithRestrictedID(input2);
   EXPECT_EQ(4u, cache.cache_.size());
-  EXPECT_EQ(kint32max, cache.last_restricted_id_);
+  EXPECT_EQ(std::numeric_limits<int32_t>::max(), cache.last_restricted_id_);
 
   output.clear();
   cache.GetCurrentItems(&output);
   EXPECT_EQ(2u, output.size());
   for (int i = 0; i < 2; ++i) {
     EXPECT_EQ(input2[i].first, output[i].first);
     EXPECT_EQ(input2[i].second, output[i].second);
   }
 
   EXPECT_FALSE(cache.GetItemWithRestrictedID(0, &t));
-  EXPECT_TRUE(cache.GetItemWithRestrictedID(kint32max, &t));
+  EXPECT_TRUE(
+      cache.GetItemWithRestrictedID(std::numeric_limits<int32_t>::max(), &t));
   EXPECT_EQ(input1[1].second, t);
-  EXPECT_TRUE(cache.GetItemWithRestrictedID(kint32min, &t));
+  EXPECT_TRUE(
+      cache.GetItemWithRestrictedID(std::numeric_limits<int32_t>::min(), &t));
   EXPECT_EQ(input2[0].second, t);
   EXPECT_TRUE(cache.GetItemWithRestrictedID(7, &t));
   EXPECT_EQ(input2[1].second, t);
 
   // Add an item without RID. last_restricted_id_ will overflow.
   std::vector<TestData> input3;
   input3.push_back(TestData("F"));
   input3.push_back(TestData("G"));
   cache.AddItems(input3);
   EXPECT_EQ(4u, cache.cache_.size());
-  EXPECT_EQ(kint32min + 1, cache.last_restricted_id_);
+  EXPECT_EQ(std::numeric_limits<int32_t>::min() + 1, cache.last_restricted_id_);
 
   output.clear();
   cache.GetCurrentItems(&output);
   EXPECT_EQ(2u, output.size());
   for (int i = 0; i < 2; ++i) {
-    EXPECT_EQ(kint32min + i, output[i].first);
+    EXPECT_EQ(std::numeric_limits<int32_t>::min() + i, output[i].first);
     EXPECT_EQ(input3[i], output[i].second);
   }
 
-  EXPECT_TRUE(cache.GetItemWithRestrictedID(kint32min, &t));
+  EXPECT_TRUE(
+      cache.GetItemWithRestrictedID(std::numeric_limits<int32_t>::min(), &t));
   EXPECT_EQ(input3[0], t);
 }
 
 TEST_F(InstantRestrictedIDCacheTest, MixIDGeneration) {
   InstantRestrictedIDCache<TestData> cache(5);
   EXPECT_EQ(0u, cache.cache_.size());
   EXPECT_EQ(0, cache.last_restricted_id_);
 
   // Add some items with manually assigned ids.
   std::vector<ItemIDPair> input1;
@@ skipping 141 matching lines @@
   // Add the same items again.
   cache.AddItemsWithRestrictedID(input1);
 
   // Make sure |cache.last_add_start_| is still valid.
   cache.GetCurrentItems(&output);
   EXPECT_EQ(3u, output.size());
   EXPECT_EQ(3u, cache.cache_.size());
   EXPECT_EQ(12, cache.last_restricted_id_);
   EXPECT_EQ(10, cache.last_add_start_->first);
 }