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

chrome_frame/chrome_active_document.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.
 
 // Implementation of ChromeActiveDocument
 #include "chrome_frame/chrome_active_document.h"
 
 #include <hlink.h>
 #include <htiface.h>
 #include <initguid.h>
@@ skipping 58 matching lines @@
 }
 
 HRESULT ChromeActiveDocument::FinalConstruct() {
   // If we have a cached ChromeActiveDocument instance in TLS, then grab
   // ownership of the cached document's automation client. This is an
   // optimization to get Chrome active documents to load faster.
   ChromeActiveDocument* cached_document = g_active_doc_cache.Get();
   if (cached_document && cached_document->IsValid()) {
     DCHECK(automation_client_.get() == NULL);
     automation_client_.swap(cached_document->automation_client_);
-    DLOG(INFO) << "Reusing automation client instance from "
-               << cached_document;
+    DVLOG(1) << "Reusing automation client instance from " << cached_document;
     DCHECK(automation_client_.get() != NULL);
     automation_client_->Reinitialize(this, url_fetcher_.get());
     is_automation_client_reused_ = true;
     OnAutomationServerReady();
   } else {
     // The FinalConstruct implementation in the ChromeFrameActivexBase class
     // i.e. Base creates an instance of the ChromeFrameAutomationClient class
     // and initializes it, which would spawn a new Chrome process, etc.
     // We don't want to be doing this if we have a cached document, whose
     // automation client instance can be reused.
@@ skipping 24 matching lines @@
 
   HMODULE this_module = reinterpret_cast<HMODULE>(&__ImageBase);
   accelerator_table_ =
     LoadAccelerators(this_module,
                      MAKEINTRESOURCE(IDR_CHROME_FRAME_IE_FULL_TAB));
   DCHECK(accelerator_table_ != NULL);
   return S_OK;
 }
 
 ChromeActiveDocument::~ChromeActiveDocument() {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
   if (find_dialog_.IsWindow())
     find_dialog_.DestroyWindow();
   // ChromeFramePlugin
   BaseActiveX::Uninitialize();
 
   TRACE_EVENT_END("chromeframe.createactivedocument", this, "");
 }
 
 // Override DoVerb
 STDMETHODIMP ChromeActiveDocument::DoVerb(LONG verb,
@@ skipping 28 matching lines @@
   return IOleObjectImpl<ChromeActiveDocument>::DoVerb(verb,
                                                       msg,
                                                       active_site,
                                                       index,
                                                       parent_window,
                                                       pos);
 }
 
 // Override IOleInPlaceActiveObjectImpl::OnDocWindowActivate
 STDMETHODIMP ChromeActiveDocument::OnDocWindowActivate(BOOL activate) {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
   return S_OK;
 }
 
 STDMETHODIMP ChromeActiveDocument::TranslateAccelerator(MSG* msg) {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
   if (msg == NULL)
     return E_POINTER;
 
   if (msg->message == WM_KEYDOWN && msg->wParam == VK_TAB) {
     HWND focus = ::GetFocus();
     if (focus != m_hWnd && !::IsChild(m_hWnd, focus)) {
       // The call to SetFocus triggers a WM_SETFOCUS that makes the base class
       // set focus to the correct element in Chrome.
       ::SetFocus(m_hWnd);
       return S_OK;
     }
   }
 
   return S_FALSE;
 }
 // Override IPersistStorageImpl::IsDirty
 STDMETHODIMP ChromeActiveDocument::IsDirty() {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
   return S_FALSE;
 }
 
 void ChromeActiveDocument::OnAutomationServerReady() {
   BaseActiveX::OnAutomationServerReady();
   BaseActiveX::GiveFocusToChrome(true);
 }
 
 STDMETHODIMP ChromeActiveDocument::Load(BOOL fully_avalable,
                                         IMoniker* moniker_name,
@@ skipping 115 matching lines @@
   if (NULL == class_id)
     return E_POINTER;
   *class_id = GetObjectCLSID();
   return S_OK;
 }
 
 STDMETHODIMP ChromeActiveDocument::QueryStatus(const GUID* cmd_group_guid,
                                                ULONG number_of_commands,
                                                OLECMD commands[],
                                                OLECMDTEXT* command_text) {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
 
   CommandStatusMap* command_map = NULL;
 
   if (cmd_group_guid) {
     if (IsEqualGUID(*cmd_group_guid, GUID_NULL)) {
       command_map = &null_group_commands_map_;
     } else if (IsEqualGUID(*cmd_group_guid, CGID_MSHTML)) {
       command_map = &mshtml_group_commands_map_;
     } else if (IsEqualGUID(*cmd_group_guid, CGID_Explorer)) {
       command_map = &explorer_group_commands_map_;
     } else if (IsEqualGUID(*cmd_group_guid, CGID_ShellDocView)) {
       command_map = &shdoc_view_group_commands_map_;
     }
   } else {
     command_map = &null_group_commands_map_;
   }
 
   if (!command_map) {
-    DLOG(INFO) << "unsupported command group: "
-        << GuidToString(*cmd_group_guid);
+    DVLOG(1) << "unsupported command group: " << GuidToString(*cmd_group_guid);
     return OLECMDERR_E_NOTSUPPORTED;
   }
 
   for (ULONG command_index = 0; command_index < number_of_commands;
        command_index++) {
-    DLOG(INFO) << "Command id = " << commands[command_index].cmdID;
+    DVLOG(1) << "Command id = " << commands[command_index].cmdID;
     CommandStatusMap::iterator index =
         command_map->find(commands[command_index].cmdID);
     if (index != command_map->end())
       commands[command_index].cmdf = index->second;
   }
   return S_OK;
 }
 
 STDMETHODIMP ChromeActiveDocument::Exec(const GUID* cmd_group_guid,
                                         DWORD command_id,
                                         DWORD cmd_exec_opt,
                                         VARIANT* in_args,
                                         VARIANT* out_args) {
-  DLOG(INFO) << __FUNCTION__ << " Cmd id =" << command_id;
+  DVLOG(1) << __FUNCTION__ << " Cmd id =" << command_id;
   // Bail out if we have been uninitialized.
   if (automation_client_.get() && automation_client_->tab()) {
     return ProcessExecCommand(cmd_group_guid, command_id, cmd_exec_opt,
                               in_args, out_args);
   } else if (command_id == OLECMDID_REFRESH && cmd_group_guid == NULL) {
     // If the automation server has crashed and the user is refreshing the
     // page, let OnRefreshPage attempt to recover.
     OnRefreshPage(cmd_group_guid, command_id, cmd_exec_opt, in_args, out_args);
   }
 
@@ skipping 215 matching lines @@
       }
     }
   }
   m_spClientSite->ShowObject();
   return S_OK;
 }
 
 void ChromeActiveDocument::OnNavigationStateChanged(int tab_handle, int flags,
     const IPC::NavigationInfo& nav_info) {
   // TODO(joshia): handle INVALIDATE_TAB,INVALIDATE_LOAD etc.
-  DLOG(INFO) << __FUNCTION__ << std::endl << " Flags: " << flags
-      << "Url: " << nav_info.url <<
-      ", Title: " << nav_info.title <<
-      ", Type: " << nav_info.navigation_type << ", Relative Offset: " <<
-      nav_info.relative_offset << ", Index: " << nav_info.navigation_index;
+  DVLOG(1) << __FUNCTION__
+           << "\n Flags: " << flags
+           << ", Url: " << nav_info.url
+           << ", Title: " << nav_info.title
+           << ", Type: " << nav_info.navigation_type
+           << ", Relative Offset: " << nav_info.relative_offset
+           << ", Index: " << nav_info.navigation_index;
 
   UpdateNavigationState(nav_info);
 }
 
 void ChromeActiveDocument::OnUpdateTargetUrl(int tab_handle,
     const std::wstring& new_target_url) {
   if (in_place_frame_)
     in_place_frame_->SetStatusText(new_target_url.c_str());
 }
 
@@ skipping 18 matching lines @@
   }
 
   if (!handled_accel) {
     if (IsFindAccelerator(accel_message)) {
       // Handle the showing of the find dialog explicitly.
       OnFindInPage();
     } else {
       BaseActiveX::OnAcceleratorPressed(tab_handle, accel_message);
     }
   } else {
-    DLOG(INFO) << "IE handled accel key " << accel_message.wParam;
+    DVLOG(1) << "IE handled accel key " << accel_message.wParam;
   }
 }
 
 void ChromeActiveDocument::OnTabbedOut(int tab_handle, bool reverse) {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
   if (in_place_frame_) {
     MSG msg = { NULL, WM_KEYDOWN, VK_TAB };
     in_place_frame_->TranslateAcceleratorW(&msg, 0);
   }
 }
 
 void ChromeActiveDocument::OnDidNavigate(int tab_handle,
                                          const IPC::NavigationInfo& nav_info) {
-  DLOG(INFO) << __FUNCTION__ << std::endl << "Url: " << nav_info.url <<
-      ", Title: " << nav_info.title <<
-      ", Type: " << nav_info.navigation_type << ", Relative Offset: " <<
-      nav_info.relative_offset << ", Index: " << nav_info.navigation_index;
+  DVLOG(1) << __FUNCTION__ << std::endl
+           << "Url: " << nav_info.url
+           << ", Title: " << nav_info.title
+           << ", Type: " << nav_info.navigation_type
+           << ", Relative Offset: " << nav_info.relative_offset
+           << ", Index: " << nav_info.navigation_index;
 
   CrashMetricsReporter::GetInstance()->IncrementMetric(
       CrashMetricsReporter::CHROME_FRAME_NAVIGATION_COUNT);
 
   // This could be NULL if the active document instance is being destroyed.
   if (!m_spInPlaceSite) {
-    DLOG(INFO) << __FUNCTION__ << "m_spInPlaceSite is NULL. Returning";
+    DVLOG(1) << __FUNCTION__ << "m_spInPlaceSite is NULL. Returning";
     return;
   }
 
   UpdateNavigationState(nav_info);
 }
 
 void ChromeActiveDocument::OnCloseTab(int tab_handle) {
   ScopedComPtr<IWebBrowser2> web_browser2;
   DoQueryService(SID_SWebBrowserApp, m_spClientSite, web_browser2.Receive());
   if (web_browser2)
@@ skipping 356 matching lines @@
       profile = GetHostProcessName(false);
     return InitializeAutomation(profile, L"", IsIEInPrivate(),
                                 false, cf_url.gurl(), GURL(referrer),
                                 false);
   }
 }
 
 
 HRESULT ChromeActiveDocument::OnRefreshPage(const GUID* cmd_group_guid,
     DWORD command_id, DWORD cmd_exec_opt, VARIANT* in_args, VARIANT* out_args) {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
   popup_allowed_ = false;
   if (in_args->vt == VT_I4 &&
       in_args->lVal & OLECMDIDF_REFRESH_PAGEACTION_POPUPWINDOW) {
     popup_allowed_ = true;
 
     // Ask the yellow security band to change the text and icon and to remain
     // visible.
     IEExec(&CGID_DocHostCommandHandler, OLECMDID_PAGEACTIONBLOCKED,
         0x80000000 | OLECMDIDF_WINDOWSTATE_USERVISIBLE_VALID, NULL, NULL);
   }
@@ skipping 112 matching lines @@
   // Like we did on SetPageFontSize, we may forward the command back to IEFrame
   // to update the menu state to indicate that which encoding was set.
   // TODO(iyengar)
   // Do some investigation into why this Exec call fails.
   IEExec(&CGID_ExplorerBarDoc, command_id, cmd_exec_opt, NULL, NULL);
   return S_OK;
 }
 
 void ChromeActiveDocument::OnGoToHistoryEntryOffset(int tab_handle,
                                                     int offset) {
-  DLOG(INFO) <<  __FUNCTION__ << " - offset:" << offset;
+  DVLOG(1) <<  __FUNCTION__ << " - offset:" << offset;
 
   ScopedComPtr<IBrowserService> browser_service;
   ScopedComPtr<ITravelLog> travel_log;
   GetBrowserServiceAndTravelLog(browser_service.Receive(),
                                 travel_log.Receive());
 
   if (browser_service && travel_log)
     travel_log->Travel(browser_service, offset);
 }
 
@@ skipping 86 matching lines @@
     GiveFocusToChrome(false);
   return 0;
 }
 
 void ChromeActiveDocument::SetWindowDimensions() {
   ScopedComPtr<IWebBrowser2> web_browser2;
   DoQueryService(SID_SWebBrowserApp, m_spClientSite,
                  web_browser2.Receive());
   if (!web_browser2)
     return;
-  DLOG(INFO) << "this:" << this;
-  DLOG(INFO) << "dimensions: width:" << dimensions_.width()
-             << "height:" << dimensions_.height();
+  DVLOG(1) << "this:" << this << "\ndimensions: width:" << dimensions_.width()
+           << " height:" << dimensions_.height();
   if (!dimensions_.IsEmpty()) {
     web_browser2->put_Width(dimensions_.width());
     web_browser2->put_Height(dimensions_.height());
     web_browser2->put_Left(dimensions_.x());
     web_browser2->put_Top(dimensions_.y());
     web_browser2->put_MenuBar(VARIANT_FALSE);
     web_browser2->put_ToolBar(VARIANT_FALSE);
 
     dimensions_.set_height(0);
     dimensions_.set_width(0);
   }
 }