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

chrome_frame/chrome_frame_automation.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/chrome_frame_automation.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/trace_event.h"
@@ skipping 205 matching lines @@
   thread_.reset(new base::Thread(WideToASCII(profile_name).c_str()));
   thread_->Start();
   // Use scoped_refptr so that the params will get released when the task
   // has been run.
   scoped_refptr<ChromeFrameLaunchParams> ref_params(params);
   thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(this,
       &AutomationProxyCacheEntry::CreateProxy, ref_params, delegate));
 }
 
 AutomationProxyCacheEntry::~AutomationProxyCacheEntry() {
-  DLOG(INFO) << __FUNCTION__ << profile_name;
+  DVLOG(1) << __FUNCTION__ << profile_name;
   // Attempt to fix chrome_frame_tests crash seen at times on the IE6/IE7
   // builders. It appears that there are cases when we can enter here when the
   // AtExitManager is tearing down the global ProxyCache which causes a crash
   // while tearing down the AutomationProxy object due to a NULL MessageLoop
   // The AutomationProxy class uses the SyncChannel which assumes the existence
   // of a MessageLoop instance.
   // We leak the AutomationProxy pointer here to avoid a crash.
   if (MessageLoop::current() == NULL) {
     proxy_.release();
   }
@@ skipping 51 matching lines @@
   // In headless mode runs like reliability test runs we want full crash dumps
   // from chrome.
   if (IsHeadlessMode())
     command_line->AppendSwitch(switches::kFullMemoryCrashReport);
 
   // In accessible mode automation tests expect renderer accessibility to be
   // enabled in chrome.
   if (IsAccessibleMode())
     command_line->AppendSwitch(switches::kForceRendererAccessibility);
 
-  DLOG(INFO) << "Profile path: " << params->profile_path().value();
+  DVLOG(1) << "Profile path: " << params->profile_path().value();
   command_line->AppendSwitchPath(switches::kUserDataDir,
                                  params->profile_path());
 
   std::wstring command_line_string(command_line->command_line_string());
   // If there are any extra arguments, append them to the command line.
   if (!params->extra_arguments().empty()) {
     command_line_string += L' ' + params->extra_arguments();
   }
 
   automation_server_launch_start_time_ = base::TimeTicks::Now();
@@ skipping 155 matching lines @@
   // Find already existing launcher thread for given profile
   AutoLock lock(lock_);
   for (size_t i = 0; i < proxies_.container().size(); ++i) {
     if (proxies_[i]->IsSameProfile(params->profile_name())) {
       entry = proxies_[i];
       break;
     }
   }
 
   if (entry == NULL) {
-    DLOG(INFO) << __FUNCTION__ << " creating new proxy entry";
+    DVLOG(1) << __FUNCTION__ << " creating new proxy entry";
     entry = new AutomationProxyCacheEntry(params, delegate);
     proxies_.container().push_back(entry);
 
     // IE uses the chrome frame provided UMA data uploading scheme. NPAPI
     // continues to use Chrome to upload UMA data.
     if (!CrashMetricsReporter::GetInstance()->active()) {
       entry->StartSendUmaInterval(&chrome_frame_histograms_,
                                   uma_send_interval_);
     }
   } else if (delegate) {
@@ skipping 510 matching lines @@
 
 // Invoked in launch background thread.
 void ChromeFrameAutomationClient::LaunchComplete(
     ChromeFrameAutomationProxy* proxy,
     AutomationLaunchResult result) {
   // If we're shutting down we don't keep a pointer to the automation server.
   if (init_state_ != UNINITIALIZING) {
     DCHECK(init_state_ == INITIALIZING);
     automation_server_ = proxy;
   } else {
-    DLOG(INFO) << "Not storing automation server pointer due to shutting down";
+    DVLOG(1) << "Not storing automation server pointer due to shutting down";
   }
 
   if (result == AUTOMATION_SUCCESS) {
     // NOTE: A potential problem here is that Uninitialize() may just have
     // been called so we need to be careful and check the automation_server_
     // pointer.
     if (automation_server_ != NULL) {
       // If we have a valid tab_handle here it means that we are attaching to
       // an existing ExternalTabContainer instance, in which case we don't
       // want to create an external tab instance in Chrome.
       if (external_tab_cookie_ == 0) {
         // Continue with Initialization - Create external tab
         CreateExternalTab();
       } else {
         // Send a notification to Chrome that we are ready to connect to the
         // ExternalTab.
         IPC::SyncMessage* message =
             new AutomationMsg_ConnectExternalTab(0, external_tab_cookie_, true,
               m_hWnd, NULL, NULL, NULL);
         automation_server_->SendAsAsync(message,
                                         new CreateExternalTabContext(this),
                                         this);
-        DLOG(INFO) << __FUNCTION__ << ": sending CreateExternalTabComplete";
+        DVLOG(1) << __FUNCTION__ << ": sending CreateExternalTabComplete";
       }
     }
   } else {
     // Launch failed. Note, we cannot delete proxy here.
     PostTask(FROM_HERE, NewRunnableMethod(this,
         &ChromeFrameAutomationClient::InitializeComplete, result));
   }
 }
 
 void ChromeFrameAutomationClient::AutomationServerDied() {
@@ skipping 402 matching lines @@
     const URLRequestStatus& status) {
   automation_server_->Send(new AutomationMsg_RequestEnd(0, tab_->handle(),
       request_id, status));
 }
 
 void ChromeFrameAutomationClient::OnCookiesRetrieved(bool success,
     const GURL& url, const std::string& cookie_string, int cookie_id) {
   automation_server_->Send(new AutomationMsg_GetCookiesHostResponse(0,
       tab_->handle(), success, url, cookie_string, cookie_id));
 }