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

chrome_frame/metrics_service.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.
 
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
@@ skipping 119 matching lines @@
 // This class provides HTTP request context information for metrics upload
 // requests initiated by ChromeFrame.
 class ChromeFrameUploadRequestContext : public URLRequestContext {
  public:
   explicit ChromeFrameUploadRequestContext(MessageLoop* io_loop)
       : io_loop_(io_loop) {
     Initialize();
   }
 
   ~ChromeFrameUploadRequestContext() {
-    DLOG(INFO) << __FUNCTION__;
+    DVLOG(1) << __FUNCTION__;
     delete http_transaction_factory_;
     delete http_auth_handler_factory_;
   }
 
   void Initialize() {
     user_agent_ = http_utils::GetDefaultUserAgent();
     user_agent_ = http_utils::AddChromeFrameToUserAgentValue(
       user_agent_);
 
     host_resolver_ =
@@ skipping 60 matching lines @@
 
   virtual scoped_refptr<base::MessageLoopProxy> GetIOMessageLoopProxy() {
     if (!io_message_loop_proxy_.get()) {
       io_message_loop_proxy_ = base::MessageLoopProxy::CreateForCurrentThread();
     }
     return io_message_loop_proxy_;
   }
 
  private:
   ~ChromeFrameUploadRequestContextGetter() {
-    DLOG(INFO) << __FUNCTION__;
+    DVLOG(1) << __FUNCTION__;
   }
 
   scoped_refptr<URLRequestContext> context_;
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
   MessageLoop* io_loop_;
 };
 
 // This class provides functionality to upload the ChromeFrame UMA data to the
 // server. An instance of this class is created whenever we have data to be
 // uploaded to the server.
 class ChromeFrameMetricsDataUploader
     : public URLFetcher::Delegate,
       public base::RefCountedThreadSafe<ChromeFrameMetricsDataUploader>,
       public CWindowImpl<ChromeFrameMetricsDataUploader>,
       public TaskMarshallerThroughWindowsMessages<
           ChromeFrameMetricsDataUploader> {
  public:
   BEGIN_MSG_MAP(ChromeFrameMetricsDataUploader)
     CHAIN_MSG_MAP(
         TaskMarshallerThroughWindowsMessages<ChromeFrameMetricsDataUploader>)
   END_MSG_MAP()
 
   ChromeFrameMetricsDataUploader()
       : fetcher_(NULL) {
-    DLOG(INFO) << __FUNCTION__;
+    DVLOG(1) << __FUNCTION__;
     creator_thread_id_ = PlatformThread::CurrentId();
   }
 
   ~ChromeFrameMetricsDataUploader() {
-    DLOG(INFO) << __FUNCTION__;
+    DVLOG(1) << __FUNCTION__;
     DCHECK(creator_thread_id_ == PlatformThread::CurrentId());
   }
 
   virtual void OnFinalMessage(HWND wnd) {
     Release();
   }
 
   bool Initialize() {
     bool ret = false;
 
@@ skipping 61 matching lines @@
     fetcher_->Start();
   }
 
   // URLFetcher::Delegate
   virtual void OnURLFetchComplete(const URLFetcher* source,
                                   const GURL& url,
                                   const URLRequestStatus& status,
                                   int response_code,
                                   const ResponseCookies& cookies,
                                   const std::string& data) {
-    DLOG(INFO) << __FUNCTION__
-               << base::StringPrintf(
-                       ": url : %hs, status:%d, response code: %d\n",
-                       url.spec().c_str(), status.status(),
-                       response_code);
+    DVLOG(1) << __FUNCTION__ << base::StringPrintf(
+        ": url : %hs, status:%d, response code: %d\n", url.spec().c_str(),
+        status.status(), response_code);
     delete fetcher_;
     fetcher_ = NULL;
 
     PostTask(FROM_HERE,
              NewRunnableMethod(this,
                                &ChromeFrameMetricsDataUploader::Uninitialize));
   }
 
  private:
   URLFetcher* fetcher_;
@@ skipping 94 matching lines @@
                                WriteInto(&guid_string, kGUIDSize), kGUIDSize);
   DCHECK(result == kGUIDSize);
   return WideToUTF8(guid_string.substr(1, guid_string.length() - 2));
 }
 
 // static
 void CALLBACK MetricsService::TransmissionTimerProc(HWND window,
                                                     unsigned int message,
                                                     unsigned int event_id,
                                                     unsigned int time) {
-  DLOG(INFO) << "Transmission timer notified";
+  DVLOG(1) << "Transmission timer notified";
   DCHECK(GetInstance() != NULL);
   GetInstance()->UploadData();
   if (GetInstance()->initial_uma_upload_) {
     // If this is the first uma upload by this process then subsequent uma
     // uploads should occur once every 10 minutes(default).
     GetInstance()->initial_uma_upload_ = false;
     DCHECK(GetInstance()->transmission_timer_id_ != 0);
     SetTimer(NULL, GetInstance()->transmission_timer_id_,
              kMinMilliSecondsPerUMAUpload,
              reinterpret_cast<TIMERPROC>(TransmissionTimerProc));
@@ skipping 93 matching lines @@
 }
 
 bool MetricsService::UploadData() {
   DCHECK_EQ(thread_, PlatformThread::CurrentId());
 
   if (!GetInstance()->TransmissionPermitted())
     return false;
 
   static long currently_uploading = 0;
   if (InterlockedCompareExchange(&currently_uploading, 1, 0)) {
-    DLOG(INFO) << "Contention for uploading metrics data. Backing off";
+    DVLOG(1) << "Contention for uploading metrics data. Backing off";
     return false;
   }
 
   std::string pending_log_text = PrepareLogSubmissionString();
   DCHECK(!pending_log_text.empty());
 
   // Allow security conscious users to see all metrics logs that we send.
-  LOG(INFO) << "METRICS LOG: " << pending_log_text;
+  VLOG(1) << "METRICS LOG: " << pending_log_text;
 
   bool ret = true;
 
   if (!Bzip2Compress(pending_log_text, &compressed_log_)) {
     NOTREACHED() << "Failed to compress log for transmission.";
     ret = false;
   } else {
     HRESULT hr = ChromeFrameMetricsDataUploader::UploadDataHelper(
         compressed_log_);
     DCHECK(SUCCEEDED(hr));
@@ skipping 14 matching lines @@
     version += "-F";
     if (!version_info.IsOfficialBuild())
       version.append("-devel");
     return version;
   } else {
     NOTREACHED() << "Unable to retrieve version string.";
   }
 
   return std::string();
 }