Revert of Remove kuint16max.

components/policy/core/browser/url_blacklist_manager.cc

 // Copyright 2014 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 "components/policy/core/browser/url_blacklist_manager.h"
 
-#include <stdint.h>
-
-#include <limits>
-
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/prefs/pref_service.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 113 matching lines @@
 
   // Returns true if |this| represents the "*" filter in the blacklist.
   bool IsBlacklistWildcard() const {
     return !allow && host.empty() && scheme.empty() && path.empty() &&
            query.empty() && port == 0 && number_of_key_value_pairs == 0 &&
            match_subdomains;
   }
 
   std::string scheme;
   std::string host;
-  uint16_t port;
+  uint16 port;
   std::string path;
   std::string query;
   int number_of_key_value_pairs;
   bool match_subdomains;
   bool allow;
 };
 
 URLBlacklist::URLBlacklist(SegmentURLCallback segment_url)
     : segment_url_(segment_url), id_(0), url_matcher_(new URLMatcher) {}
 
@@ skipping 77 matching lines @@
 size_t URLBlacklist::Size() const {
   return filters_.size();
 }
 
 // static
 bool URLBlacklist::FilterToComponents(SegmentURLCallback segment_url,
                                       const std::string& filter,
                                       std::string* scheme,
                                       std::string* host,
                                       bool* match_subdomains,
-                                      uint16_t* port,
+                                      uint16* port,
                                       std::string* path,
                                       std::string* query) {
   url::Parsed parsed;
 
   if (segment_url(filter, &parsed) == url::kFileScheme) {
     base::FilePath file_path;
     if (!net::FileURLToFilePath(GURL(filter), &file_path))
       return false;
 
     *scheme = url::kFileScheme;
@@ skipping 42 matching lines @@
       *match_subdomains = false;
     }
   }
 
   if (parsed.port.is_nonempty()) {
     int int_port;
     if (!base::StringToInt(filter.substr(parsed.port.begin, parsed.port.len),
                            &int_port)) {
       return false;
     }
-    if (int_port <= 0 || int_port > std::numeric_limits<uint16_t>::max())
+    if (int_port <= 0 || int_port > kuint16max)
       return false;
     *port = int_port;
   } else {
     // Match any port.
     *port = 0;
   }
 
   if (parsed.path.is_nonempty())
     path->assign(filter, parsed.path.begin, parsed.path.len);
   else
     path->clear();
 
   if (query) {
     if (parsed.query.is_nonempty())
       query->assign(filter, parsed.query.begin, parsed.query.len);
     else
       query->clear();
   }
 
   return true;
 }
 
 // static
 scoped_refptr<URLMatcherConditionSet> URLBlacklist::CreateConditionSet(
     URLMatcher* url_matcher,
     int id,
     const std::string& scheme,
     const std::string& host,
     bool match_subdomains,
-    uint16_t port,
+    uint16 port,
     const std::string& path,
     const std::string& query,
     bool allow) {
   URLMatcherConditionFactory* condition_factory =
       url_matcher->condition_factory();
   std::set<URLMatcherCondition> conditions;
   conditions.insert(match_subdomains ?
       condition_factory->CreateHostSuffixPathPrefixCondition(host, path) :
       condition_factory->CreateHostEqualsPathPrefixCondition(host, path));
 
@@ skipping 159 matching lines @@
 }
 
 // static
 void URLBlacklistManager::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterListPref(policy_prefs::kUrlBlacklist);
   registry->RegisterListPref(policy_prefs::kUrlWhitelist);
 }
 
 }  // namespace policy