[Sync] use base::Time in sync

chrome/browser/sync/glue/session_model_associator.cc

 // Copyright (c) 2011 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/sync/glue/session_model_associator.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 180 matching lines @@
         *header_window = window_s;
 
         // Update this window's representation in the synced session tracker.
         if (window_num >= current_session->windows.size()) {
           // This a new window, create it.
           current_session->windows.push_back(new SessionWindow());
         }
         PopulateSessionWindowFromSpecifics(
             local_tag,
             window_s,
-            base::Time::Now().ToInternalValue(),
+            base::Time::Now(),
             current_session->windows[window_num++],
             &synced_session_tracker_);
       }
     }
   }
 
   sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   sync_api::WriteNode header_node(&trans);
   if (!header_node.InitByIdLookup(local_session_syncid_)) {
     LOG(ERROR) << "Failed to load local session header node.";
@@ skipping 119 matching lines @@
   tab_s->set_current_navigation_index(current_index);
 
   tab_node.SetSessionSpecifics(session_s);
 
   // Convert to a local representation and store in synced session tracker.
   SessionTab* session_tab =
       synced_session_tracker_.GetSessionTab(GetCurrentMachineTag(),
                                             tab_s->tab_id(),
                                             false);
   PopulateSessionTabFromSpecifics(*tab_s,
-                                  base::Time::Now().ToInternalValue(),
+                                  base::Time::Now(),
                                   session_tab);
   return true;
 }
 
 // Static
 // TODO(zea): perhaps sync state (scroll position, form entries, etc.) as well?
 // See http://crbug.com/67068.
 void SessionModelAssociator::PopulateSessionSpecificsNavigation(
     const TabNavigation* navigation,
     sync_pb::TabNavigation* tab_navigation) {
@@ skipping 222 matching lines @@
   int64 id = root.GetFirstChildId();
   while (id != sync_api::kInvalidId) {
     sync_api::ReadNode sync_node(trans);
     if (!sync_node.InitByIdLookup(id)) {
       LOG(ERROR) << "Failed to fetch sync node for id " << id;
       return false;
     }
 
     const sync_pb::SessionSpecifics& specifics =
         sync_node.GetSessionSpecifics();
-    const int64 modification_time = sync_node.GetModificationTime();
+    const base::Time& modification_time = sync_node.GetModificationTime();
     if (specifics.session_tag() != GetCurrentMachineTag()) {
       if (!AssociateForeignSpecifics(specifics, modification_time)) {
         return false;
       }
     } else if (id != local_session_syncid_) {
       // This is previously stored local session information.
       if (specifics.has_header()) {
         if (sync_api::kInvalidId != local_session_syncid_)
           return false;
 
@@ skipping 18 matching lines @@
 
   // After updating from sync model all tabid's should be free.
   if (!tab_pool_.full())
     return false;
 
   return true;
 }
 
 bool SessionModelAssociator::AssociateForeignSpecifics(
     const sync_pb::SessionSpecifics& specifics,
-    const int64 modification_time) {
+    const base::Time& modification_time) {
   DCHECK(CalledOnValidThread());
   std::string foreign_session_tag = specifics.session_tag();
   if (foreign_session_tag == GetCurrentMachineTag() && !setup_for_test_)
     return false;
 
   if (specifics.has_header()) {
     // Read in the header data for this foreign session.
     // Header data contains window information and ordered tab id's for each
     // window.
 
@@ skipping 73 matching lines @@
         session_header->device_type = SyncedSession::TYPE_OTHER;
         break;
     }
   }
 }
 
 // Static
 void SessionModelAssociator::PopulateSessionWindowFromSpecifics(
     const std::string& session_tag,
     const sync_pb::SessionWindow& specifics,
-    int64 mtime,
+    const base::Time& mtime,
     SessionWindow* session_window,
     SyncedSessionTracker* tracker) {
   if (specifics.has_window_id())
     session_window->window_id.set_id(specifics.window_id());
   if (specifics.has_selected_tab_index())
     session_window->selected_tab_index = specifics.selected_tab_index();
   if (specifics.has_browser_type()) {
     if (specifics.browser_type() ==
         sync_pb::SessionWindow_BrowserType_TYPE_TABBED) {
       session_window->type = 1;
     } else {
       session_window->type = 2;
     }
   }
-  session_window->timestamp = base::Time::FromInternalValue(mtime);
+  session_window->timestamp = mtime;
   session_window->tabs.resize(specifics.tab_size());
   for (int i = 0; i < specifics.tab_size(); i++) {
     SessionID::id_type tab_id = specifics.tab(i);
     session_window->tabs[i] =
         tracker->GetSessionTab(session_tag, tab_id, true);
   }
 }
 
 // Static
 void SessionModelAssociator::PopulateSessionTabFromSpecifics(
     const sync_pb::SessionTab& specifics,
-    const int64 mtime,
+    const base::Time& mtime,
     SessionTab* tab) {
   if (specifics.has_tab_id())
     tab->tab_id.set_id(specifics.tab_id());
   if (specifics.has_window_id())
     tab->window_id.set_id(specifics.window_id());
   if (specifics.has_tab_visual_index())
     tab->tab_visual_index = specifics.tab_visual_index();
   if (specifics.has_current_navigation_index())
     tab->current_navigation_index = specifics.current_navigation_index();
   if (specifics.has_pinned())
     tab->pinned = specifics.pinned();
   if (specifics.has_extension_app_id())
     tab->extension_app_id = specifics.extension_app_id();
-  tab->timestamp = base::Time::FromInternalValue(mtime);
+  tab->timestamp = mtime;
   tab->navigations.clear();  // In case we are reusing a previous SessionTab.
   for (int i = 0; i < specifics.navigation_size(); i++) {
     AppendSessionTabNavigation(specifics.navigation(i), &tab->navigations);
   }
 }
 
 // Static
 void SessionModelAssociator::AppendSessionTabNavigation(
     const sync_pb::TabNavigation& specifics,
     std::vector<TabNavigation>* navigations) {
@@ skipping 421 matching lines @@
   char computer_name[MAX_COMPUTERNAME_LENGTH + 1];
   DWORD size = sizeof(computer_name);
   if (GetComputerNameA(computer_name, &size)) {
     return computer_name;
   }
   return std::string();
 }
 #endif
 
 }  // namespace browser_sync