[chrome/browser/s*] Convert VLOGs to DVLOGs

chrome/browser/sessions/session_service_commands.cc

 // Copyright 2014 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/sessions/session_service_commands.h"
 
 #include <vector>
 
 #include "base/pickle.h"
 #include "chrome/browser/sessions/base_session_service_commands.h"
@@ skipping 249 matching lines @@
       }
       ++i;
     }
   }
 }
 
 // Adds tabs to their parent window based on the tab's window_id. This
 // ignores tabs with no navigations.
 void AddTabsToWindows(std::map<int, SessionTab*>* tabs,
                       std::map<int, SessionWindow*>* windows) {
-  VLOG(1) << "AddTabsToWindws";
-  VLOG(1) << "Tabs " << tabs->size() << ", windows " << windows->size();
+  DVLOG(1) << "AddTabsToWindws";
+  DVLOG(1) << "Tabs " << tabs->size() << ", windows " << windows->size();
   std::map<int, SessionTab*>::iterator i = tabs->begin();
   while (i != tabs->end()) {
     SessionTab* tab = i->second;
     if (tab->window_id.id() && !tab->navigations.empty()) {
       SessionWindow* window = GetWindow(tab->window_id.id(), windows);
       window->tabs.push_back(tab);
       tabs->erase(i++);
 
       // See note in SessionTab as to why we do this.
       std::vector<sessions::SerializedNavigationEntry>::iterator j =
@@ skipping 20 matching lines @@
 // to delete the tabs and windows added to |tabs| and |windows|.
 //
 // This does NOT add any created SessionTabs to SessionWindow.tabs, that is
 // done by AddTabsToWindows.
 bool CreateTabsAndWindows(const ScopedVector<SessionCommand>& data,
                           std::map<int, SessionTab*>* tabs,
                           std::map<int, SessionWindow*>* windows,
                           SessionID::id_type* active_window_id) {
   // If the file is corrupt (command with wrong size, or unknown command), we
   // still return true and attempt to restore what we we can.
-  VLOG(1) << "CreateTabsAndWindows";
+  DVLOG(1) << "CreateTabsAndWindows";
 
   for (std::vector<SessionCommand*>::const_iterator i = data.begin();
        i != data.end(); ++i) {
     const SessionCommand::id_type kCommandSetWindowBounds2 = 10;
     const SessionCommand* command = *i;
 
-    VLOG(1) << "Read command " << (int) command->id();
+    DVLOG(1) << "Read command " << (int) command->id();
     switch (command->id()) {
       case kCommandSetTabWindow: {
         SessionID::id_type payload[2];
         if (!command->GetPayload(payload, sizeof(payload))) {
-          VLOG(1) << "Failed reading command " << command->id();
+          DVLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         GetTab(payload[1], tabs)->window_id.set_id(payload[0]);
         break;
       }
 
       // This is here for forward migration only.  New data is saved with
       // |kCommandSetWindowBounds3|.
       case kCommandSetWindowBounds2: {
         WindowBoundsPayload2 payload;
         if (!command->GetPayload(&payload, sizeof(payload))) {
-          VLOG(1) << "Failed reading command " << command->id();
+          DVLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         GetWindow(payload.window_id, windows)->bounds.SetRect(payload.x,
                                                               payload.y,
                                                               payload.w,
                                                               payload.h);
         GetWindow(payload.window_id, windows)->show_state =
             payload.is_maximized ?
                 ui::SHOW_STATE_MAXIMIZED : ui::SHOW_STATE_NORMAL;
         break;
       }
 
       case kCommandSetWindowBounds3: {
         WindowBoundsPayload3 payload;
         if (!command->GetPayload(&payload, sizeof(payload))) {
-          VLOG(1) << "Failed reading command " << command->id();
+          DVLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         GetWindow(payload.window_id, windows)->bounds.SetRect(payload.x,
                                                               payload.y,
                                                               payload.w,
                                                               payload.h);
         GetWindow(payload.window_id, windows)->show_state =
             PersistedShowStateToShowState(payload.show_state);
         break;
       }
 
       case kCommandSetTabIndexInWindow: {
         TabIndexInWindowPayload payload;
         if (!command->GetPayload(&payload, sizeof(payload))) {
-          VLOG(1) << "Failed reading command " << command->id();
+          DVLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         GetTab(payload.id, tabs)->tab_visual_index = payload.index;
         break;
       }
 
       case kCommandTabClosed:
       case kCommandWindowClosed: {
         ClosedPayload payload;
         if (!command->GetPayload(&payload, sizeof(payload))) {
-          VLOG(1) << "Failed reading command " << command->id();
+          DVLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         if (command->id() == kCommandTabClosed) {
           delete GetTab(payload.id, tabs);
           tabs->erase(payload.id);
         } else {
           delete GetWindow(payload.id, windows);
           windows->erase(payload.id);
         }
         break;
       }
 
       case kCommandTabNavigationPathPrunedFromBack: {
         TabNavigationPathPrunedFromBackPayload payload;
         if (!command->GetPayload(&payload, sizeof(payload))) {
-          VLOG(1) << "Failed reading command " << command->id();
+          DVLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         SessionTab* tab = GetTab(payload.id, tabs);
         tab->navigations.erase(
             FindClosestNavigationWithIndex(&(tab->navigations), payload.index),
             tab->navigations.end());
         break;
       }
 
       case kCommandTabNavigationPathPrunedFromFront: {
         TabNavigationPathPrunedFromFrontPayload payload;
         if (!command->GetPayload(&payload, sizeof(payload)) ||
             payload.index <= 0) {
-          VLOG(1) << "Failed reading command " << command->id();
+          DVLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         SessionTab* tab = GetTab(payload.id, tabs);
 
         // Update the selected navigation index.
         tab->current_navigation_index =
             std::max(-1, tab->current_navigation_index - payload.index);
 
         // And update the index of existing navigations.
         for (std::vector<sessions::SerializedNavigationEntry>::iterator
                  i = tab->navigations.begin();
              i != tab->navigations.end();) {
           i->set_index(i->index() - payload.index);
           if (i->index() < 0)
             i = tab->navigations.erase(i);
           else
             ++i;
         }
         break;
       }
 
       case kCommandUpdateTabNavigation: {
         sessions::SerializedNavigationEntry navigation;
         SessionID::id_type tab_id;
         if (!RestoreUpdateTabNavigationCommand(*command,
                                                &navigation,
                                                &tab_id)) {
-          VLOG(1) << "Failed reading command " << command->id();
+          DVLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         SessionTab* tab = GetTab(tab_id, tabs);
         std::vector<sessions::SerializedNavigationEntry>::iterator i =
             FindClosestNavigationWithIndex(&(tab->navigations),
                                            navigation.index());
         if (i != tab->navigations.end() && i->index() == navigation.index())
           *i = navigation;
         else
           tab->navigations.insert(i, navigation);
         break;
       }
 
       case kCommandSetSelectedNavigationIndex: {
         SelectedNavigationIndexPayload payload;
         if (!command->GetPayload(&payload, sizeof(payload))) {
-          VLOG(1) << "Failed reading command " << command->id();
+          DVLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         GetTab(payload.id, tabs)->current_navigation_index = payload.index;
         break;
       }
 
       case kCommandSetSelectedTabInIndex: {
         SelectedTabInIndexPayload payload;
         if (!command->GetPayload(&payload, sizeof(payload))) {
-          VLOG(1) << "Failed reading command " << command->id();
+          DVLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         GetWindow(payload.id, windows)->selected_tab_index = payload.index;
         break;
       }
 
       case kCommandSetWindowType: {
         WindowTypePayload payload;
         if (!command->GetPayload(&payload, sizeof(payload))) {
-          VLOG(1) << "Failed reading command " << command->id();
+          DVLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         GetWindow(payload.id, windows)->is_constrained = false;
         GetWindow(payload.id, windows)->type =
             static_cast<SessionWindow::WindowType>(payload.index);
         break;
       }
 
       case kCommandSetPinnedState: {
         PinnedStatePayload payload;
         if (!command->GetPayload(&payload, sizeof(payload))) {
-          VLOG(1) << "Failed reading command " << command->id();
+          DVLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         GetTab(payload.tab_id, tabs)->pinned = payload.pinned_state;
         break;
       }
 
       case kCommandSetWindowAppName: {
         SessionID::id_type window_id;
         std::string app_name;
         if (!RestoreSetWindowAppNameCommand(*command, &window_id, &app_name))
           return true;
 
         GetWindow(window_id, windows)->app_name.swap(app_name);
         break;
       }
 
       case kCommandSetExtensionAppID: {
         SessionID::id_type tab_id;
         std::string extension_app_id;
         if (!RestoreSetTabExtensionAppIDCommand(*command,
                                                 &tab_id,
                                                 &extension_app_id)) {
-          VLOG(1) << "Failed reading command " << command->id();
+          DVLOG(1) << "Failed reading command " << command->id();
           return true;
         }
 
         GetTab(tab_id, tabs)->extension_app_id.swap(extension_app_id);
         break;
       }
 
       case kCommandSetTabUserAgentOverride: {
         SessionID::id_type tab_id;
         std::string user_agent_override;
@@ skipping 18 matching lines @@
           return true;
         // Associate the session storage back.
         GetTab(command_tab_id, tabs)->session_storage_persistent_id =
             session_storage_persistent_id;
         break;
       }
 
       case kCommandSetActiveWindow: {
         ActiveWindowPayload payload;
         if (!command->GetPayload(&payload, sizeof(payload))) {
-          VLOG(1) << "Failed reading command " << command->id();
+          DVLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         *active_window_id = payload;
         break;
       }
 
       default:
         // TODO(skuhne): This might call back into a callback handler to extend
         // the command set for specific implementations.
-        VLOG(1) << "Failed reading an unknown command " << command->id();
+        DVLOG(1) << "Failed reading an unknown command " << command->id();
         return true;
     }
   }
   return true;
 }
 
 }  // namespace
 
 scoped_ptr<SessionCommand> CreateSetSelectedTabInWindowCommand(
     const SessionID& window_id,
@@ skipping 246 matching lines @@
   return command->id() == kCommandTabClosed ||
          command->id() == kCommandWindowClosed;
 }
 
 void RestoreSessionFromCommands(const ScopedVector<SessionCommand>& commands,
                                 std::vector<SessionWindow*>* valid_windows,
                                 SessionID::id_type* active_window_id) {
   std::map<int, SessionTab*> tabs;
   std::map<int, SessionWindow*> windows;
 
-  VLOG(1) << "RestoreSessionFromCommands " << commands.size();
+  DVLOG(1) << "RestoreSessionFromCommands " << commands.size();
   if (CreateTabsAndWindows(commands, &tabs, &windows, active_window_id)) {
     AddTabsToWindows(&tabs, &windows);
     SortTabsBasedOnVisualOrderAndPrune(&windows, valid_windows);
     UpdateSelectedTabIndex(valid_windows);
   }
   STLDeleteValues(&tabs);
   // Don't delete contents of windows, that is done by the caller as all
   // valid windows are added to valid_windows.
 }