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

chrome_frame/chrome_frame_npapi.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_npapi.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_split.h"
@@ skipping 407 matching lines @@
     // We have opened the URL so tell the browser to restore popup settings
     enabled_popups_ = false;
     npapi::PopPopupsEnabledState(instance_);
   }
 
   url_fetcher_.UrlNotify(url, reason, notify_data);
 }
 
 void ChromeFrameNPAPI::OnAcceleratorPressed(int tab_handle,
                                             const MSG& accel_message) {
-  DLOG(INFO) << __FUNCTION__ << " msg:"
-      << base::StringPrintf("0x%04X", accel_message.message) << " key:"
-      << accel_message.wParam;
+  DVLOG(1) << __FUNCTION__
+           << " msg:" << base::StringPrintf("0x%04X", accel_message.message)
+           << " key:" << accel_message.wParam;
 
   // The host browser does call TranslateMessage on messages like WM_KEYDOWN
   // WM_KEYUP, etc, which will result in messages like WM_CHAR, WM_SYSCHAR, etc
   // being posted to the message queue. We don't post these messages here to
   // avoid these messages from getting handled twice.
   if (!is_privileged_ &&
       accel_message.message != WM_CHAR &&
       accel_message.message != WM_DEADCHAR &&
       accel_message.message != WM_SYSCHAR &&
       accel_message.message != WM_SYSDEADCHAR) {
     // A very primitive way to handle keystrokes.
     // TODO(tommi): When we've implemented a way for chrome to
     //  know when keystrokes are handled (deterministically) on that side,
     //  then this function should get called and not otherwise.
     ::PostMessage(::GetParent(m_hWnd), accel_message.message,
                   accel_message.wParam, accel_message.lParam);
   }
 
   if (automation_client_.get()) {
     TabProxy* tab = automation_client_->tab();
     if (tab) {
       tab->ProcessUnhandledAccelerator(accel_message);
     }
   }
 }
 
 void ChromeFrameNPAPI::OnTabbedOut(int tab_handle, bool reverse) {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
 
   ignore_setfocus_ = true;
   HWND parent = ::GetParent(m_hWnd);
   ::SetFocus(parent);
 
   INPUT input = {0};
   input.type = INPUT_KEYBOARD;
   input.ki.wVk = VK_TAB;
   SendInput(1, &input, sizeof(input));
   input.ki.dwFlags = KEYEVENTF_KEYUP;
@@ skipping 255 matching lines @@
   ChromeFrameNPAPI* plugin_instance = ChromeFrameInstanceFromNPObject(object);
   if (!plugin_instance) {
     NOTREACHED();
     return false;
   }
 
   return plugin_instance->SetProperty(name, variant);
 }
 
 void ChromeFrameNPAPI::OnFocus() {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
   PostMessage(WM_SETFOCUS, 0, 0);
 }
 
 void ChromeFrameNPAPI::OnEvent(const char* event_name) {
   DCHECK(event_name);
-  DLOG(INFO) << event_name;
+  DVLOG(1) << event_name;
 
   if (lstrcmpiA(event_name, "focus") == 0) {
     OnFocus();
   } else if (lstrcmpiA(event_name, "blur") == 0) {
     OnBlur();
   } else {
     NOTREACHED() << event_name;
   }
 }
 
@@ skipping 20 matching lines @@
   // twice for WM_SETFOCUS.
   BOOL handled_by_base = TRUE;
   LRESULT ret = Base::OnSetFocus(message, wparam, lparam, handled_by_base);
   if (hook)
     ::UnhookWindowsHookEx(hook);
 
   return ret;
 }
 
 void ChromeFrameNPAPI::OnBlur() {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
 }
 
 void ChromeFrameNPAPI::OnLoad(int, const GURL& gurl) {
-  DLOG(INFO) << "Firing onload";
+  DVLOG(1) << "Firing onload";
   FireEvent("load", gurl.spec());
 }
 
 void ChromeFrameNPAPI::OnLoadFailed(int error_code, const std::string& url) {
   FireEvent("loaderror", url);
 
   ScopedNpVariant result;
   InvokeDefault(onerror_handler_, url, &result);
 }
 
@@ skipping 672 matching lines @@
 }
 
 int32 ChromeFrameNPAPI::Write(NPStream* stream, int32 offset, int32 len,
                               void* buffer) {
   return url_fetcher_.Write(stream, offset, len, buffer);
 }
 
 NPError ChromeFrameNPAPI::DestroyStream(NPStream* stream, NPReason reason) {
   return url_fetcher_.DestroyStream(stream, reason);
 }