net: Add namespace net to Sdch* classes.

net/base/sdch_manager.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 "net/base/sdch_manager.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/sha2.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "net/base/registry_controlled_domain.h"
 #include "net/url_request/url_request_http_job.h"
 
-using base::Time;
-using base::TimeDelta;
+namespace net {
 
 //------------------------------------------------------------------------------
 // static
 const size_t SdchManager::kMaxDictionarySize = 1000000;
 
 // static
 const size_t SdchManager::kMaxDictionaryCount = 20;
 
 // static
 SdchManager* SdchManager::global_;
 
 //------------------------------------------------------------------------------
 SdchManager::Dictionary::Dictionary(const std::string& dictionary_text,
-    size_t offset, const std::string& client_hash, const GURL& gurl,
-    const std::string& domain, const std::string& path, const Time& expiration,
-    const std::set<int> ports)
-      : text_(dictionary_text, offset),
-        client_hash_(client_hash),
-        url_(gurl),
-        domain_(domain),
-        path_(path),
-        expiration_(expiration),
-        ports_(ports) {
+                                    size_t offset,
+                                    const std::string& client_hash,
+                                    const GURL& gurl,
+                                    const std::string& domain,
+                                    const std::string& path,
+                                    const base::Time& expiration,
+                                    const std::set<int>& ports)
+    : text_(dictionary_text, offset),
+      client_hash_(client_hash),
+      url_(gurl),
+      domain_(domain),
+      path_(path),
+      expiration_(expiration),
+      ports_(ports) {
 }
 
 SdchManager::Dictionary::~Dictionary() {
 }
 
 bool SdchManager::Dictionary::CanAdvertise(const GURL& target_url) {
   if (!SdchManager::Global()->IsInSupportedDomain(target_url))
     return false;
   /* The specific rules of when a dictionary should be advertised in an
      Avail-Dictionary header are modeled after the rules for cookie scoping. The
      terms "domain-match" and "pathmatch" are defined in RFC 2965 [6]. A
      dictionary may be advertised in the Avail-Dictionaries header exactly when
      all of the following are true:
       1. The server's effective host name domain-matches the Domain attribute of
          the dictionary.
       2. If the dictionary has a Port attribute, the request port is one of the
          ports listed in the Port attribute.
       3. The request URI path-matches the path header of the dictionary.
       4. The request is not an HTTPS request.
     */
   if (!DomainMatch(target_url, domain_))
     return false;
   if (!ports_.empty() && 0 == ports_.count(target_url.EffectiveIntPort()))
     return false;
   if (path_.size() && !PathMatch(target_url.path(), path_))
     return false;
   if (target_url.SchemeIsSecure())
     return false;
-  if (Time::Now() > expiration_)
+  if (base::Time::Now() > expiration_)
     return false;
   return true;
 }
 
 //------------------------------------------------------------------------------
 // Security functions restricting loads and use of dictionaries.
 
 // static
 bool SdchManager::Dictionary::CanSet(const std::string& domain,
                                      const std::string& path,
@@ skipping 283 matching lines @@
   std::string client_hash;
   std::string server_hash;
   GenerateHash(dictionary_text, &client_hash, &server_hash);
   if (dictionaries_.find(server_hash) != dictionaries_.end()) {
     SdchErrorRecovery(DICTIONARY_ALREADY_LOADED);
     return false;  // Already loaded.
   }
 
   std::string domain, path;
   std::set<int> ports;
-  Time expiration(Time::Now() + TimeDelta::FromDays(30));
+  base::Time expiration(base::Time::Now() + base::TimeDelta::FromDays(30));
 
   if (dictionary_text.empty()) {
     SdchErrorRecovery(DICTIONARY_HAS_NO_TEXT);
     return false;  // Missing header.
   }
 
   size_t header_end = dictionary_text.find("\n\n");
   if (std::string::npos == header_end) {
     SdchErrorRecovery(DICTIONARY_HAS_NO_HEADER);
     return false;  // Missing header.
@@ skipping 24 matching lines @@
       if (name == "domain") {
         domain = value;
       } else if (name == "path") {
         path = value;
       } else if (name == "format-version") {
         if (value != "1.0")
           return false;
       } else if (name == "max-age") {
         int64 seconds;
         base::StringToInt64(value, &seconds);
-        expiration = Time::Now() + TimeDelta::FromSeconds(seconds);
+        expiration = base::Time::Now() + base::TimeDelta::FromSeconds(seconds);
       } else if (name == "port") {
         int port;
         base::StringToInt(value, &port);
         if (port >= 0)
           ports.insert(port);
       }
     }
 
     if (line_end >= header_end)
       break;
@@ skipping 107 matching lines @@
         (*output)[i] = '-';
         continue;
       case '/':
         (*output)[i] = '_';
         continue;
       default:
         continue;
     }
   }
 }
+
+}  // namespace net