Convert LOG(INFO) to VLOG(1) - chrome/browser/chromeos/login/....

chrome/browser/chromeos/login/screen_locker.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/browser/chromeos/login/screen_locker.h"
 
 #include <string>
 #include <vector>
 
 #include "app/l10n_util.h"
@@ skipping 57 matching lines @@
                        const NotificationDetails& details) {
     if (type == NotificationType::LOGIN_USER_CHANGED) {
       // Register Screen Lock after login screen to make sure
       // we don't show the screen lock on top of the login screen by accident.
       if (chromeos::CrosLibrary::Get()->EnsureLoaded())
         chromeos::CrosLibrary::Get()->GetScreenLockLibrary()->AddObserver(this);
     }
   }
 
   virtual void LockScreen(chromeos::ScreenLockLibrary* obj) {
-    LOG(INFO) << "In: ScreenLockObserver::LockScreen";
+    VLOG(1) << "In: ScreenLockObserver::LockScreen";
     SetupInputMethodsForScreenLocker();
     chromeos::ScreenLocker::Show();
   }
 
   virtual void UnlockScreen(chromeos::ScreenLockLibrary* obj) {
     RestoreInputMethods();
     chromeos::ScreenLocker::Hide();
   }
 
   virtual void UnlockScreenFailed(chromeos::ScreenLockLibrary* obj) {
@@ skipping 100 matching lines @@
     // Don't handle key event in the lock window.
     return false;
   }
 
   virtual gboolean OnKeyRelease(GtkWidget* widget, GdkEventKey* event) {
     // Don't handle key event in the lock window.
     return false;
   }
 
   virtual void OnDestroy(GtkWidget* object) {
-    LOG(INFO) << "OnDestroy: LockWindow destroyed";
+    VLOG(1) << "OnDestroy: LockWindow destroyed";
     views::WidgetGtk::OnDestroy(object);
   }
 
   virtual void ClearNativeFocus() {
     DCHECK(toplevel_focus_widget_);
     gtk_widget_grab_focus(toplevel_focus_widget_);
   }
 
   // Sets the widget to move the focus to when clearning the native
   // widget's focus.
@@ skipping 103 matching lines @@
         << kbd_grab_status_ << ", mouse=" << mouse_grab_status_;
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         task_factory_.NewRunnableMethod(&GrabWidget::TryGrabAllInputs),
         kRetryGrabIntervalMs);
   } else {
     CHECK_EQ(GDK_GRAB_SUCCESS, kbd_grab_status_)
         << "Failed to grab keyboard input:" << kbd_grab_status_;
     CHECK_EQ(GDK_GRAB_SUCCESS, mouse_grab_status_)
         << "Failed to grab pointer input:" << mouse_grab_status_;
-    DLOG(INFO) << "Grab Success";
+    DVLOG(1) << "Grab Success";
     screen_locker_->OnGrabInputs();
   }
 }
 
 // BackgroundView for ScreenLocker, which layouts a lock widget in
 // addition to other background components.
 class ScreenLockerBackgroundView : public chromeos::BackgroundView {
  public:
   explicit ScreenLockerBackgroundView(views::WidgetGtk* lock_widget)
       : lock_widget_(lock_widget) {
@@ skipping 229 matching lines @@
   // Don't let X draw default background, which was causing flash on
   // resume.
   gdk_window_set_back_pixmap(lock_window_->GetNativeView()->window,
                              NULL, false);
   gdk_window_set_back_pixmap(lock_widget_->GetNativeView()->window,
                              NULL, false);
   lock_window->set_toplevel_focus_widget(lock_widget_->window_contents());
 }
 
 void ScreenLocker::OnLoginFailure(const LoginFailure& error) {
-  DLOG(INFO) << "OnLoginFailure";
+  DVLOG(1) << "OnLoginFailure";
   EnableInput();
   // Don't enable signout button here as we're showing
   // MessageBubble.
   gfx::Rect rect = screen_lock_view_->GetPasswordBoundsRelativeTo(
       lock_widget_->GetRootView());
   gfx::Rect lock_widget_bounds;
   lock_widget_->GetBounds(&lock_widget_bounds, false);
   rect.Offset(lock_widget_bounds.x(), lock_widget_bounds.y());
 
   if (error_info_)
@@ skipping 22 matching lines @@
   mouse_event_relay_.reset(
       new MouseEventRelay(lock_widget_->GetNativeView()->window,
                           error_info_->GetNativeView()->window));
   MessageLoopForUI::current()->AddObserver(mouse_event_relay_.get());
 }
 
 void ScreenLocker::OnLoginSuccess(
     const std::string& username,
     const GaiaAuthConsumer::ClientLoginResult& unused,
     bool pending_requests) {
-  LOG(INFO) << "OnLoginSuccess: Sending Unlock request.";
+  VLOG(1) << "OnLoginSuccess: Sending Unlock request.";
   if (CrosLibrary::Get()->EnsureLoaded())
     CrosLibrary::Get()->GetScreenLockLibrary()->NotifyScreenUnlockRequested();
 }
 
 void ScreenLocker::InfoBubbleClosing(InfoBubble* info_bubble,
                                      bool closed_by_escape) {
   error_info_ = NULL;
   screen_lock_view_->SetSignoutEnabled(true);
   if (mouse_event_relay_.get()) {
     MessageLoopForUI::current()->RemoveObserver(mouse_event_relay_.get());
@@ skipping 32 matching lines @@
     if (CrosLibrary::Get()->EnsureLoaded()) {
       CrosLibrary::Get()->GetLoginLibrary()->StopSession("");
     }
 
     // Don't hide yet the locker because the chrome screen may become visible
     // briefly.
   }
 }
 
 void ScreenLocker::OnGrabInputs() {
-  DLOG(INFO) << "OnGrabInputs";
+  DVLOG(1) << "OnGrabInputs";
   input_grabbed_ = true;
   if (drawn_)
     ScreenLockReady();
 }
 
 // static
 void ScreenLocker::Show() {
-  LOG(INFO) << "In ScreenLocker::Show";
+  VLOG(1) << "In ScreenLocker::Show";
   DCHECK(MessageLoop::current()->type() == MessageLoop::TYPE_UI);
 
   // Exit fullscreen.
   Browser* browser = BrowserList::GetLastActive();
   // browser can be NULL if we receive a lock request before the first browser
   // window is shown.
   if (browser && browser->window()->IsFullscreen()) {
     browser->ToggleFullscreenMode();
   }
 
   if (!screen_locker_) {
-    LOG(INFO) << "Show: Locking screen";
+    VLOG(1) << "Show: Locking screen";
     ScreenLocker* locker =
         new ScreenLocker(UserManager::Get()->logged_in_user());
     locker->Init();
   } else {
     // PowerManager re-sends lock screen signal if it doesn't
     // receive the response within timeout. Just send complete
     // signal.
-    LOG(INFO) << "Show: locker already exists. "
-              << "just sending completion event";
+    VLOG(1) << "Show: locker already exists. Just sending completion event.";
     if (CrosLibrary::Get()->EnsureLoaded())
       CrosLibrary::Get()->GetScreenLockLibrary()->NotifyScreenLockCompleted();
   }
 }
 
 // static
 void ScreenLocker::Hide() {
   DCHECK(MessageLoop::current()->type() == MessageLoop::TYPE_UI);
   DCHECK(screen_locker_);
-  LOG(INFO) << "Hide: Deleting ScreenLocker:" << screen_locker_;
+  VLOG(1) << "Hide: Deleting ScreenLocker: " << screen_locker_;
   MessageLoopForUI::current()->DeleteSoon(FROM_HERE, screen_locker_);
 }
 
 // static
 void ScreenLocker::UnlockScreenFailed() {
   DCHECK(MessageLoop::current()->type() == MessageLoop::TYPE_UI);
   if (screen_locker_) {
     // Power manager decided no to unlock the screen even if a user
     // typed in password, for example, when a user closed the lid
     // immediately after typing in the password.
-    LOG(INFO) << "UnlockScreenFailed: re-enabling screen locker";
+    VLOG(1) << "UnlockScreenFailed: re-enabling screen locker.";
     screen_locker_->EnableInput();
   } else {
     // This can happen when a user requested unlock, but PowerManager
     // rejected because the computer is closed, then PowerManager unlocked
     // because it's open again and the above failure message arrives.
     // This'd be extremely rare, but may still happen.
-    LOG(INFO) << "UnlockScreenFailed: screen is already unlocked.";
+    VLOG(1) << "UnlockScreenFailed: screen is already unlocked.";
   }
 }
 
 // static
 void ScreenLocker::InitClass() {
   Singleton<ScreenLockObserver>::get();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ScreenLocker, private:
 
 ScreenLocker::~ScreenLocker() {
   DCHECK(MessageLoop::current()->type() == MessageLoop::TYPE_UI);
   ClearErrors();
   if (input_event_observer_.get())
     MessageLoopForUI::current()->RemoveObserver(input_event_observer_.get());
   if (locker_input_event_observer_.get()) {
     lock_widget_->GetFocusManager()->UnregisterAccelerator(
         views::Accelerator(app::VKEY_ESCAPE, false, false, false), this);
     MessageLoopForUI::current()->RemoveObserver(
         locker_input_event_observer_.get());
   }
 
   gdk_keyboard_ungrab(GDK_CURRENT_TIME);
   gdk_pointer_ungrab(GDK_CURRENT_TIME);
 
   DCHECK(lock_window_);
-  LOG(INFO) << "~ScreenLocker(): Closing ScreenLocker window";
+  VLOG(1) << "~ScreenLocker(): Closing ScreenLocker window.";
   lock_window_->Close();
   // lock_widget_ will be deleted by gtk's destroy signal.
   screen_locker_ = NULL;
   bool state = false;
   NotificationService::current()->Notify(
       NotificationType::SCREEN_LOCK_STATE_CHANGED,
       Source<ScreenLocker>(this),
       Details<bool>(&state));
   if (CrosLibrary::Get()->EnsureLoaded())
     CrosLibrary::Get()->GetScreenLockLibrary()->NotifyScreenUnlockCompleted();
 }
 
 void ScreenLocker::SetAuthenticator(Authenticator* authenticator) {
   authenticator_ = authenticator;
 }
 
 void ScreenLocker::ScreenLockReady() {
-  LOG(INFO) << "ScreenLockReady: sending completed signal to power manager.";
+  VLOG(1) << "ScreenLockReady: sending completed signal to power manager.";
   locked_ = true;
   if (background_view_->ScreenSaverEnabled()) {
     lock_widget_->GetFocusManager()->RegisterAccelerator(
         views::Accelerator(app::VKEY_ESCAPE, false, false, false), this);
     locker_input_event_observer_.reset(new LockerInputEventObserver(this));
     MessageLoopForUI::current()->AddObserver(
         locker_input_event_observer_.get());
   } else {
     // Don't enable the password field until we grab all inputs.
     EnableInput();
@@ skipping 10 matching lines @@
 
 void ScreenLocker::OnClientEvent(GtkWidget* widge, GdkEventClient* event) {
   WmIpc::Message msg;
   WmIpc::instance()->DecodeMessage(*event, &msg);
   if (msg.type() == WM_IPC_MESSAGE_CHROME_NOTIFY_SCREEN_REDRAWN_FOR_LOCK) {
     OnWindowManagerReady();
   }
 }
 
 void ScreenLocker::OnWindowManagerReady() {
-  DLOG(INFO) << "OnClientEvent: drawn for lock";
+  DVLOG(1) << "OnClientEvent: drawn for lock";
   drawn_ = true;
   if (input_grabbed_)
     ScreenLockReady();
 }
 
 void ScreenLocker::StopScreenSaver() {
   if (background_view_->IsScreenSaverVisible()) {
-    LOG(INFO) << "StopScreenSaver";
+    VLOG(1) << "StopScreenSaver";
     background_view_->HideScreenSaver();
     if (screen_lock_view_) {
       screen_lock_view_->SetVisible(true);
       screen_lock_view_->RequestFocus();
     }
     EnableInput();
   }
 }
 
 void ScreenLocker::StartScreenSaver() {
   if (!background_view_->IsScreenSaverVisible()) {
-    LOG(INFO) << "StartScreenSaver";
+    VLOG(1) << "StartScreenSaver";
     background_view_->ShowScreenSaver();
     if (screen_lock_view_) {
       screen_lock_view_->SetEnabled(false);
       screen_lock_view_->SetVisible(false);
     }
     ClearErrors();
   }
 }
 
 bool ScreenLocker::AcceleratorPressed(const views::Accelerator& accelerator) {
   if (!background_view_->IsScreenSaverVisible()) {
     StartScreenSaver();
     return true;
   }
   return false;
 }
 
 }  // namespace chromeos