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

chrome_frame/test/ie_event_sink.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/test/ie_event_sink.h"
 
 #include "base/scoped_bstr_win.h"
 #include "base/scoped_handle.h"
 #include "base/scoped_variant_win.h"
 #include "base/string_util.h"
@@ skipping 403 matching lines @@
 }
 
 STDMETHODIMP_(void) IEEventSink::OnNewWindow2(IDispatch** disp,
                                               VARIANT_BOOL* s) {
   if (listener_)
     listener_->OnNewWindow2(disp, s);
 }
 
 STDMETHODIMP_(void) IEEventSink::OnNavigateError(IDispatch* dispatch,
     VARIANT* url, VARIANT* frame_name, VARIANT* status_code, VARIANT* cancel) {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
   if (listener_)
     listener_->OnNavigateError(dispatch, url, frame_name, status_code, cancel);
 }
 
 STDMETHODIMP IEEventSink::OnBeforeNavigate2(
     IDispatch* dispatch, VARIANT* url, VARIANT* flags,
     VARIANT* target_frame_name, VARIANT* post_data, VARIANT* headers,
     VARIANT_BOOL* cancel) {
-  DLOG(INFO) << __FUNCTION__
-      << base::StringPrintf("%ls - 0x%08X", url->bstrVal, this);
+  DVLOG(1) << __FUNCTION__
+           << base::StringPrintf("%ls - 0x%08X", url->bstrVal, this);
   // Reset any existing reference to chrome frame since this is a new
   // navigation.
   DisconnectFromChromeFrame();
   if (listener_)
     listener_->OnBeforeNavigate2(dispatch, url, flags, target_frame_name,
                                  post_data, headers, cancel);
   return S_OK;
 }
 
 STDMETHODIMP_(void) IEEventSink::OnNavigateComplete2(
     IDispatch* dispatch, VARIANT* url) {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
   ConnectToChromeFrame();
   if (listener_)
     listener_->OnNavigateComplete2(dispatch, url);
 }
 
 STDMETHODIMP_(void) IEEventSink::OnDocumentComplete(
     IDispatch* dispatch, VARIANT* url) {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
   EXPECT_TRUE(url);
   if (!url)
     return;
   if (listener_)
     listener_->OnDocumentComplete(dispatch, url);
 }
 
 STDMETHODIMP_(void) IEEventSink::OnFileDownload(
     VARIANT_BOOL active_doc, VARIANT_BOOL* cancel) {
-  DLOG(INFO) << __FUNCTION__ << base::StringPrintf(" 0x%08X ad=%i", this,
-                                                   active_doc);
+  DVLOG(1) << __FUNCTION__
+           << base::StringPrintf(" 0x%08X ad=%i", this, active_doc);
   if (listener_)
     listener_->OnFileDownload(active_doc, cancel);
   // Always cancel file downloads in tests.
   *cancel = VARIANT_TRUE;
 }
 
 STDMETHODIMP_(void) IEEventSink::OnNewWindow3(
     IDispatch** dispatch, VARIANT_BOOL* cancel, DWORD flags, BSTR url_context,
     BSTR url) {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
   EXPECT_TRUE(dispatch);
   if (!dispatch)
     return;
 
   if (listener_)
     listener_->OnNewWindow3(dispatch, cancel, flags, url_context, url);
 
   // Note that |dispatch| is an [in/out] argument. IE is asking listeners if
   // they want to use a IWebBrowser2 of their choice for the new window.
   // Since we need to listen on events on the new browser, we create one
   // if needed.
   if (!*dispatch) {
     ScopedComPtr<IDispatch> new_browser;
     HRESULT hr = new_browser.CreateInstance(CLSID_InternetExplorer, NULL,
                                             CLSCTX_LOCAL_SERVER);
     DCHECK(SUCCEEDED(hr) && new_browser);
     *dispatch = new_browser.Detach();
   }
 
   if (*dispatch)
     listener_->OnNewBrowserWindow(*dispatch, url);
 }
 
 STDMETHODIMP_(void) IEEventSink::OnQuit() {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
 
   did_receive_on_quit_ = true;
 
   DispEventUnadvise(web_browser2_);
   CoDisconnectObject(this, 0);
 
   if (listener_)
     listener_->OnQuit();
 }
 
 HRESULT IEEventSink::OnLoad(const VARIANT* param) {
-  DLOG(INFO) << __FUNCTION__ << " " << param->bstrVal;
+  DVLOG(1) << __FUNCTION__ << " " << param->bstrVal;
   ScopedVariant stack_object(*param);
   if (chrome_frame_) {
     if (listener_)
       listener_->OnLoad(param->bstrVal);
   } else {
     DLOG(WARNING) << "Invalid chrome frame pointer";
   }
   return S_OK;
 }
 
 HRESULT IEEventSink::OnLoadError(const VARIANT* param) {
-  DLOG(INFO) << __FUNCTION__ << " " << param->bstrVal;
+  DVLOG(1) << __FUNCTION__ << " " << param->bstrVal;
   if (chrome_frame_) {
     if (listener_)
       listener_->OnLoadError(param->bstrVal);
   } else {
     DLOG(WARNING) << "Invalid chrome frame pointer";
   }
   return S_OK;
 }
 
 HRESULT IEEventSink::OnMessage(const VARIANT* param) {
-  DLOG(INFO) << __FUNCTION__ << " " << param;
+  DVLOG(1) << __FUNCTION__ << " " << param;
   if (!chrome_frame_.get()) {
     DLOG(WARNING) << "Invalid chrome frame pointer";
     return S_OK;
   }
 
   ScopedVariant data, origin, source;
   if (param && (V_VT(param) == VT_DISPATCH)) {
     wchar_t* properties[] = { L"data", L"origin", L"source" };
     const int prop_count = arraysize(properties);
     DISPID ids[prop_count] = {0};
@@ skipping 13 matching lines @@
           source.Receive(), NULL, NULL));
     }
   }
 
   if (listener_)
     listener_->OnMessage(V_BSTR(&data), V_BSTR(&origin), V_BSTR(&source));
   return S_OK;
 }
 
 }  // namespace chrome_frame_test