Convert LOG(INFO) to VLOG(1) - chrome_frame/.

chrome_frame/npapi_url_request.cc

 // Copyright (c) 2010 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 "chrome_frame/npapi_url_request.h"
 
 #include "base/string_number_conversions.h"
 #include "chrome_frame/np_browser_functions.h"
 #include "chrome_frame/np_utils.h"
 #include "net/base/net_errors.h"
@@ skipping 38 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(NPAPIUrlRequest);
 };
 
 int NPAPIUrlRequest::instance_count_ = 0;
 
 NPAPIUrlRequest::NPAPIUrlRequest(NPP instance)
     : ref_count_(0), instance_(instance), stream_(NULL),
       pending_read_size_(0),
       status_(URLRequestStatus::FAILED, net::ERR_FAILED),
       thread_(PlatformThread::CurrentId()) {
-  DLOG(INFO) << "Created request. Count: " << ++instance_count_;
+  DVLOG(1) << "Created request. Count: " << ++instance_count_;
 }
 
 NPAPIUrlRequest::~NPAPIUrlRequest() {
-  DLOG(INFO) << "Deleted request. Count: " << --instance_count_;
+  DVLOG(1) << "Deleted request. Count: " << --instance_count_;
 }
 
 // NPAPIUrlRequest member defines.
 bool NPAPIUrlRequest::Start() {
   NPError result = NPERR_GENERIC_ERROR;
-  DLOG(INFO) << "Starting URL request: " << url();
+  DVLOG(1) << "Starting URL request: " << url();
   if (LowerCaseEqualsASCII(method(), "get")) {
     // TODO(joshia): if we have extra headers for HTTP GET, then implement
     // it using XHR
     result = npapi::GetURLNotify(instance_, url().c_str(), NULL, this);
   } else if (LowerCaseEqualsASCII(method(), "post")) {
     uint32 data_len = static_cast<uint32>(post_data_len());
 
     std::string buffer;
     if (extra_headers().length() > 0) {
       buffer += extra_headers();
@@ skipping 32 matching lines @@
 
     delegate_->OnResponseEnd(id(),
         URLRequestStatus(URLRequestStatus::FAILED, os_error));
     return false;
   }
 
   return true;
 }
 
 void NPAPIUrlRequest::Stop() {
-  DLOG(INFO) << "Finished request: Url - " << url() << " result: "
-      << static_cast<int>(status_.status());
+  DVLOG(1) << "Finished request: Url - " << url()
+           << " result: " << static_cast<int>(status_.status());
 
   status_.set_status(URLRequestStatus::CANCELED);
   if (stream_) {
     npapi::DestroyStream(instance_, stream_, NPRES_USER_BREAK);
     stream_ = NULL;
   }
 }
 
 bool NPAPIUrlRequest::Read(int bytes_to_read) {
   pending_read_size_ = bytes_to_read;
@@ skipping 129 matching lines @@
   }
 }
 
 void NPAPIUrlRequestManager::SetCookiesForUrl(const GURL& url,
                                               const std::string& cookie) {
   // Use the newer NPAPI way if available
   if (npapi::VersionMinor() >= NPVERS_HAS_URL_AND_AUTH_INFO) {
     npapi::SetValueForURL(instance_, NPNURLVCookie, url.spec().c_str(),
                           cookie.c_str(), cookie.length());
   } else {
-    DLOG(INFO) << "Host does not support NPVERS_HAS_URL_AND_AUTH_INFO.";
-    DLOG(INFO) << "Attempting to set cookie using XPCOM cookie service";
+    DVLOG(1) << "Host does not support NPVERS_HAS_URL_AND_AUTH_INFO.  "
+                "Attempting to set cookie using XPCOM cookie service";
     if (np_utils::SetCookiesUsingXPCOMCookieService(instance_, url.spec(),
                                                     cookie)) {
-      DLOG(INFO) << "Successfully set cookies using XPCOM cookie service";
-      DLOG(INFO) << cookie.c_str();
+      DVLOG(1) << "Successfully set cookies using XPCOM cookie service "
+               << cookie;
     } else {
       NOTREACHED() << "Failed to set cookies for host";
     }
   }
 }
 
 void NPAPIUrlRequestManager::GetCookiesForUrl(const GURL& url, int cookie_id) {
   std::string cookie_string;
   bool success = true;
 
   if (npapi::VersionMinor() >= NPVERS_HAS_URL_AND_AUTH_INFO) {
     char* cookies = NULL;
     unsigned int cookie_length = 0;
     NPError ret = npapi::GetValueForURL(instance_, NPNURLVCookie,
                                         url.spec().c_str(), &cookies,
                                         &cookie_length);
     if (ret == NPERR_NO_ERROR) {
-      DLOG(INFO) << "Obtained cookies:" << cookies << " from host";
+      DVLOG(1) << "Obtained cookies:" << cookies << " from host";
       cookie_string.append(cookies, cookie_length);
       npapi::MemFree(cookies);
     } else {
       success = false;
     }
   } else {
-    DLOG(INFO) << "Host does not support NPVERS_HAS_URL_AND_AUTH_INFO.";
-    DLOG(INFO) << "Attempting to read cookie using XPCOM cookie service";
+    DVLOG(1) << "Host does not support NPVERS_HAS_URL_AND_AUTH_INFO.  "
+                "Attempting to read cookie using XPCOM cookie service";
     if (np_utils::GetCookiesUsingXPCOMCookieService(instance_, url.spec(),
                                                     &cookie_string)) {
-      DLOG(INFO) << "Successfully read cookies using XPCOM cookie service";
-      DLOG(INFO) << cookie_string.c_str();
+      DVLOG(1) << "Successfully read cookies using XPCOM cookie service "
+               << cookie_string;
     } else {
       success = false;
     }
   }
 
   if (!success)
-    DLOG(INFO) << "Failed to return cookies for url:" << url.spec().c_str();
+    DVLOG(1) << "Failed to return cookies for url:" << url.spec();
 
   OnCookiesRetrieved(success, url, cookie_string, cookie_id);
 }
 
 // PluginRequestDelegate implementation.
 // Callbacks from NPAPIUrlRequest. Simply forward to the delegate.
 void NPAPIUrlRequestManager::OnResponseStarted(int request_id,
     const char* mime_type, const char* headers, int size,
     base::Time last_modified, const std::string& redirect_url,
     int redirect_status) {
@@ skipping 90 matching lines @@
   }
 }
 
 scoped_refptr<NPAPIUrlRequest> NPAPIUrlRequestManager::LookupRequest(
     int request_id) {
   RequestMap::iterator index = request_map_.find(request_id);
   if (index != request_map_.end())
     return index->second;
   return NULL;
 }