More non-debug logging in Chrome Frame tests.

chrome_frame/test/ie_event_sink.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 "chrome_frame/test/ie_event_sink.h"
 
 #include <shlguid.h>
 #include <shobjidl.h>
 
 #include <map>
@@ skipping 248 matching lines @@
         LOG(ERROR) << "OnQuit was not received for browser with url "
                    << browser_url_string;
         web_browser2_->Quit();
       }
 
       base::win::ScopedHandle process;
       process.Set(OpenProcess(SYNCHRONIZE, FALSE, ie_process_id_));
       web_browser2_.Release();
 
       if (!process.IsValid()) {
-        DLOG_IF(WARNING, !process.IsValid())
+        LOG_IF(WARNING, !process.IsValid())
             << base::StringPrintf("OpenProcess failed: %i", ::GetLastError());
         return;
       }
       // IE may not have closed yet. Wait here for the process to finish.
       // This is necessary at least on some browser/platform configurations.
       WaitForSingleObject(process, kDefaultWaitForIEToTerminateMs);
     }
   } else {
     LOG(ERROR) << "Terminating hung IE process";
   }
@@ skipping 275 matching lines @@
 }
 
 // Event callbacks
 STDMETHODIMP_(void) IEEventSink::OnDownloadBegin() {
   if (listener_)
     listener_->OnDownloadBegin();
 }
 
 STDMETHODIMP_(void) IEEventSink::OnNewWindow2(IDispatch** dispatch,
                                               VARIANT_BOOL* s) {
-  DVLOG(1) << __FUNCTION__;
+  VLOG(1) << __FUNCTION__;
 
   EXPECT_TRUE(dispatch);
   if (!dispatch)
     return;
 
   if (listener_)
     listener_->OnNewWindow2(dispatch, s);
 
   // 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) {
     base::win::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_)
     listener_->OnNewBrowserWindow(*dispatch, ScopedBstr());
 }
 
 STDMETHODIMP_(void) IEEventSink::OnNavigateError(IDispatch* dispatch,
     VARIANT* url, VARIANT* frame_name, VARIANT* status_code, VARIANT* cancel) {
-  DVLOG(1) << __FUNCTION__;
+  VLOG(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) {
-  DVLOG(1) << __FUNCTION__
-           << base::StringPrintf("%ls - 0x%08X", url->bstrVal, this);
+  VLOG(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) {
-  DVLOG(1) << __FUNCTION__;
+  VLOG(1) << __FUNCTION__;
   ConnectToChromeFrame();
   if (listener_)
     listener_->OnNavigateComplete2(dispatch, url);
 }
 
 STDMETHODIMP_(void) IEEventSink::OnDocumentComplete(
     IDispatch* dispatch, VARIANT* url) {
-  DVLOG(1) << __FUNCTION__;
+  VLOG(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) {
-  DVLOG(1) << __FUNCTION__
-           << base::StringPrintf(" 0x%08X ad=%i", this, active_doc);
+  VLOG(1) << __FUNCTION__ << " "
+          << base::StringPrintf(" 0x%08X ad=%i", this, active_doc);
   if (listener_) {
     listener_->OnFileDownload(active_doc, cancel);
   } else {
     *cancel = VARIANT_TRUE;
   }
 }
 
 STDMETHODIMP_(void) IEEventSink::OnNewWindow3(
     IDispatch** dispatch, VARIANT_BOOL* cancel, DWORD flags, BSTR url_context,
     BSTR url) {
-  DVLOG(1) << __FUNCTION__;
+  VLOG(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) {
     base::win::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_)
     listener_->OnNewBrowserWindow(*dispatch, url);
 }
 
 STDMETHODIMP_(void) IEEventSink::OnQuit() {
-  DVLOG(1) << __FUNCTION__;
+  VLOG(1) << __FUNCTION__;
 
   did_receive_on_quit_ = true;
 
   DispEventUnadvise(web_browser2_);
   CoDisconnectObject(this, 0);
 
   if (listener_)
     listener_->OnQuit();
 }
 
 STDMETHODIMP IEEventSink::Invoke(DISPID dispid, REFIID riid, LCID lcid,
                                  WORD flags, DISPPARAMS* params,
                                  VARIANT* result, EXCEPINFO* except_info,
                                  UINT* arg_error) {
   VLOG(1) << __FUNCTION__ << L" event: " << g_dispIdToName.Get().Lookup(dispid);
   return DispEventsImpl::Invoke(dispid, riid, lcid, flags, params, result,
                                 except_info, arg_error);
 }
 
 HRESULT IEEventSink::OnLoad(const VARIANT* param) {
-  DVLOG(1) << __FUNCTION__ << " " << param->bstrVal;
+  VLOG(1) << __FUNCTION__ << " " << param->bstrVal;
   base::win::ScopedVariant stack_object(*param);
   if (chrome_frame_) {
     if (listener_)
       listener_->OnLoad(param->bstrVal);
   } else {
-    DLOG(WARNING) << "Invalid chrome frame pointer";
+    LOG(WARNING) << "Invalid chrome frame pointer";
   }
   return S_OK;
 }
 
 HRESULT IEEventSink::OnLoadError(const VARIANT* param) {
-  DVLOG(1) << __FUNCTION__ << " " << param->bstrVal;
+  VLOG(1) << __FUNCTION__ << " " << param->bstrVal;
   if (chrome_frame_) {
     if (listener_)
       listener_->OnLoadError(param->bstrVal);
   } else {
-    DLOG(WARNING) << "Invalid chrome frame pointer";
+    LOG(WARNING) << "Invalid chrome frame pointer";
   }
   return S_OK;
 }
 
 HRESULT IEEventSink::OnMessage(const VARIANT* param) {
-  DVLOG(1) << __FUNCTION__ << " " << param;
+  VLOG(1) << __FUNCTION__ << " " << param;
   if (!chrome_frame_.get()) {
-    DLOG(WARNING) << "Invalid chrome frame pointer";
+    LOG(WARNING) << "Invalid chrome frame pointer";
     return S_OK;
   }
 
   base::win::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};
 
     HRESULT hr = param->pdispVal->GetIDsOfNames(IID_NULL, properties,
@@ skipping 11 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