Add quic_logging

net/tools/quic/quic_http_response_cache.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 "net/tools/quic/quic_http_response_cache.h"
 
 #include <utility>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "net/http/http_util.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
+#include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_text_utils.h"
 #include "net/spdy/spdy_http_utils.h"
 
 using base::FilePath;
 using base::IntToString;
 using base::StringPiece;
 using std::string;
 
 namespace net {
 
@@ skipping 20 matching lines @@
 QuicHttpResponseCache::Response::~Response() {}
 
 void QuicHttpResponseCache::ResourceFile::Read() {
   base::ReadFileToString(FilePath(file_name_), &file_contents_);
 
   // First read the headers.
   size_t start = 0;
   while (start < file_contents_.length()) {
     size_t pos = file_contents_.find("\n", start);
     if (pos == string::npos) {
-      LOG(DFATAL) << "Headers invalid or empty, ignoring: "
-                  << file_name_.value();
+      QUIC_LOG(DFATAL) << "Headers invalid or empty, ignoring: "
+                       << file_name_.value();
       return;
     }
     size_t len = pos - start;
     // Support both dos and unix line endings for convenience.
     if (file_contents_[pos - 1] == '\r') {
       len -= 1;
     }
     StringPiece line(file_contents_.data() + start, len);
     start = pos + 1;
     // Headers end with an empty line.
     if (line.empty()) {
       break;
     }
     // Extract the status from the HTTP first line.
     if (line.substr(0, 4) == "HTTP") {
       pos = line.find(" ");
       if (pos == string::npos) {
-        LOG(DFATAL) << "Headers invalid or empty, ignoring: "
-                    << file_name_.value();
+        QUIC_LOG(DFATAL) << "Headers invalid or empty, ignoring: "
+                         << file_name_.value();
         return;
       }
       spdy_headers_[":status"] = line.substr(pos + 1, 3);
       continue;
     }
     // Headers are "key: value".
     pos = line.find(": ");
     if (pos == string::npos) {
-      LOG(DFATAL) << "Headers invalid or empty, ignoring: "
-                  << file_name_.value();
+      QUIC_LOG(DFATAL) << "Headers invalid or empty, ignoring: "
+                       << file_name_.value();
       return;
     }
     spdy_headers_.AppendValueOrAddHeader(
         QuicTextUtils::ToLower(line.substr(0, pos)), line.substr(pos + 2));
   }
 
   // The connection header is prohibited in HTTP/2.
   spdy_headers_.erase("connection");
 
   // Override the URL with the X-Original-Url header, if present.
@@ skipping 132 matching lines @@
 }
 
 QuicHttpResponseCache::QuicHttpResponseCache() {}
 
 void QuicHttpResponseCache::InitializeFromDirectory(
     const string& cache_directory) {
   if (cache_directory.empty()) {
     QUIC_BUG << "cache_directory must not be empty.";
     return;
   }
-  VLOG(1) << "Attempting to initialize QuicHttpResponseCache from directory: "
-          << cache_directory;
+  QUIC_LOG(INFO)
+      << "Attempting to initialize QuicHttpResponseCache from directory: "
+      << cache_directory;
   FilePath directory(FilePath::FromUTF8Unsafe(cache_directory));
   base::FileEnumerator file_list(directory, true, base::FileEnumerator::FILES);
   std::list<std::unique_ptr<ResourceFile>> resource_files;
   for (FilePath file_iter = file_list.Next(); !file_iter.empty();
        file_iter = file_list.Next()) {
     // Need to skip files in .svn directories
     if (file_iter.value().find(FILE_PATH_LITERAL("/.svn/")) != string::npos) {
       continue;
     }
 
@@ skipping 35 matching lines @@
 
 std::list<ServerPushInfo> QuicHttpResponseCache::GetServerPushResources(
     string request_url) {
   QuicWriterMutexLock lock(&response_mutex_);
 
   std::list<ServerPushInfo> resources;
   auto resource_range = server_push_resources_.equal_range(request_url);
   for (auto it = resource_range.first; it != resource_range.second; ++it) {
     resources.push_back(it->second);
   }
-  DVLOG(1) << "Found " << resources.size() << " push resources for "
-           << request_url;
+  QUIC_DVLOG(1) << "Found " << resources.size() << " push resources for "
+                << request_url;
   return resources;
 }
 
 QuicHttpResponseCache::~QuicHttpResponseCache() {
   {
     QuicWriterMutexLock lock(&response_mutex_);
     responses_.clear();
   }
 }
 
 void QuicHttpResponseCache::AddResponseImpl(StringPiece host,
                                             StringPiece path,
                                             SpecialResponseType response_type,
                                             SpdyHeaderBlock response_headers,
                                             StringPiece response_body,
                                             SpdyHeaderBlock response_trailers) {
   QuicWriterMutexLock lock(&response_mutex_);
 
   DCHECK(!host.empty()) << "Host must be populated, e.g. \"www.google.com\"";
   string key = GetKey(host, path);
   if (base::ContainsKey(responses_, key)) {
     QUIC_BUG << "Response for '" << key << "' already exists!";
     return;
   }
   std::unique_ptr<Response> new_response = base::MakeUnique<Response>();
   new_response->set_response_type(response_type);
   new_response->set_headers(std::move(response_headers));
   new_response->set_body(response_body);
   new_response->set_trailers(std::move(response_trailers));
-  DVLOG(1) << "Add response with key " << key;
+  QUIC_DVLOG(1) << "Add response with key " << key;
   responses_[key] = std::move(new_response);
 }
 
 string QuicHttpResponseCache::GetKey(StringPiece host, StringPiece path) const {
   return host.as_string() + path.as_string();
 }
 
 void QuicHttpResponseCache::MaybeAddServerPushResources(
     StringPiece request_host,
     StringPiece request_path,
     std::list<ServerPushInfo> push_resources) {
   string request_url = GetKey(request_host, request_path);
 
   for (const auto& push_resource : push_resources) {
     if (PushResourceExistsInCache(request_url, push_resource)) {
       continue;
     }
 
-    DVLOG(1) << "Add request-resource association: request url " << request_url
-             << " push url " << push_resource.request_url
-             << " response headers " << push_resource.headers.DebugString();
+    QUIC_DVLOG(1) << "Add request-resource association: request url "
+                  << request_url << " push url " << push_resource.request_url
+                  << " response headers "
+                  << push_resource.headers.DebugString();
     {
       QuicWriterMutexLock lock(&response_mutex_);
       server_push_resources_.insert(std::make_pair(request_url, push_resource));
     }
     string host = push_resource.request_url.host();
     if (host.empty()) {
       host = request_host.as_string();
     }
     string path = push_resource.request_url.path();
     bool found_existing_response = false;
     {
       QuicWriterMutexLock lock(&response_mutex_);
       found_existing_response =
           base::ContainsKey(responses_, GetKey(host, path));
     }
     if (!found_existing_response) {
       // Add a server push response to responses map, if it is not in the map.
       StringPiece body = push_resource.body;
-      DVLOG(1) << "Add response for push resource: host " << host << " path "
-               << path;
+      QUIC_DVLOG(1) << "Add response for push resource: host " << host
+                    << " path " << path;
       AddResponse(host, path, push_resource.headers.Clone(), body);
     }
   }
 }
 
 bool QuicHttpResponseCache::PushResourceExistsInCache(
     string original_request_url,
     ServerPushInfo resource) {
   QuicWriterMutexLock lock(&response_mutex_);
   auto resource_range =
       server_push_resources_.equal_range(original_request_url);
   for (auto it = resource_range.first; it != resource_range.second; ++it) {
     ServerPushInfo push_resource = it->second;
     if (push_resource.request_url.spec() == resource.request_url.spec()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net