Revert 99391 (broke CrOS unit_tests) - Set user-visible machine names and devices types for synce...

chrome/browser/ui/webui/sessions_ui.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/ui/webui/sessions_ui.h"
 
 #include <algorithm>
 
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/glue/session_model_associator.h"
-#include "chrome/browser/sync/glue/synced_session.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_data_source.h"
 #include "chrome/browser/ui/webui/ntp/new_tab_ui.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/webui/web_ui.h"
 #include "grit/browser_resources.h"
@@ skipping 53 matching lines @@
   browser_sync::SessionModelAssociator* GetModelAssociator();
 
   // Appends each entry in |tabs| to |tab_list| as a DictonaryValue.
   void GetTabList(const std::vector<SessionTab*>& tabs, ListValue* tab_list);
 
   // Appends each entry in |windows| to |window_list| as a DictonaryValue.
   void GetWindowList(const std::vector<SessionWindow*>& windows,
                      ListValue* window_list);
 
   // Appends each entry in |sessions| to |session_list| as a DictonaryValue.
-  void GetSessionList(
-      const std::vector<const browser_sync::SyncedSession*>& sessions,
-      ListValue* session_list);
+  void GetSessionList(const std::vector<const SyncedSession*>& sessions,
+                      ListValue* session_list);
 
   // Traverses all tabs in |sessions| and adds them to |all_tabs|.
-  void GetAllTabs(
-      const std::vector<const browser_sync::SyncedSession*>& sessions,
-      std::vector<SessionTab*>* all_tabs);
+  void GetAllTabs(const std::vector<const SyncedSession*>& sessions,
+                  std::vector<SessionTab*>* all_tabs);
 
   // Creates a "magic" list of tabs from all the sessions.
-  void CreateMagicTabList(
-      const std::vector<const browser_sync::SyncedSession*>& sessions,
-      ListValue* tab_list);
+  void CreateMagicTabList(const std::vector<const SyncedSession*>& sessions,
+                          ListValue* tab_list);
 
   DISALLOW_COPY_AND_ASSIGN(SessionsDOMHandler);
 };
 
 SessionsDOMHandler::SessionsDOMHandler() {
 }
 
 SessionsDOMHandler::~SessionsDOMHandler() {
 }
 
@@ skipping 57 matching lines @@
     window_data->SetDouble("timestamp",
         static_cast<double> (window->timestamp.ToInternalValue()));
     scoped_ptr<ListValue> tab_list(new ListValue());
     GetTabList(window->tabs, tab_list.get());
     window_data->Set("tabs", tab_list.release());
     window_list->Append(window_data.release());
   }
 }
 
 void SessionsDOMHandler::GetSessionList(
-    const std::vector<const browser_sync::SyncedSession*>& sessions,
+    const std::vector<const SyncedSession*>& sessions,
     ListValue* session_list) {
-  for (std::vector<const browser_sync::SyncedSession*>::const_iterator it =
+  for (std::vector<const SyncedSession*>::const_iterator it =
        sessions.begin(); it != sessions.end(); ++it) {
-    const browser_sync::SyncedSession* session = *it;
+    const SyncedSession* session = *it;
     scoped_ptr<DictionaryValue> session_data(new DictionaryValue());
     session_data->SetString("tag", session->session_tag);
     scoped_ptr<ListValue> window_list(new ListValue());
     GetWindowList(session->windows, window_list.get());
     session_data->Set("windows", window_list.release());
     session_list->Append(session_data.release());
   }
 }
 
 void SessionsDOMHandler::GetAllTabs(
-    const std::vector<const browser_sync::SyncedSession*>& sessions,
+    const std::vector<const SyncedSession*>& sessions,
     std::vector<SessionTab*>* all_tabs) {
   for (size_t i = 0; i < sessions.size(); i++) {
     const std::vector<SessionWindow*>& windows = sessions[i]->windows;
     for (size_t j = 0; j < windows.size(); j++) {
       const std::vector<SessionTab*>& tabs = windows[j]->tabs;
       all_tabs->insert(all_tabs->end(), tabs.begin(), tabs.end());
     }
   }
 }
 
 // Comparator function for sort() in CreateMagicTabList() below.
 bool CompareTabsByTimestamp(SessionTab* lhs, SessionTab* rhs) {
   return lhs->timestamp.ToInternalValue() > rhs->timestamp.ToInternalValue();
 }
 
 void SessionsDOMHandler::CreateMagicTabList(
-    const std::vector<const browser_sync::SyncedSession*>& sessions,
+    const std::vector<const SyncedSession*>& sessions,
     ListValue* tab_list) {
   std::vector<SessionTab*> all_tabs;
   GetAllTabs(sessions, &all_tabs);
 
   // Sort the list by timestamp - newest first.
   std::sort(all_tabs.begin(), all_tabs.end(), CompareTabsByTimestamp);
 
   // Truncate the list if necessary.
   const size_t kMagicTabListMaxSize = 10;
   if (all_tabs.size() > kMagicTabListMaxSize)
     all_tabs.resize(kMagicTabListMaxSize);
 
   GetTabList(all_tabs, tab_list);
 }
 
 void SessionsDOMHandler::UpdateUI() {
   ListValue session_list;
   ListValue magic_list;
 
   browser_sync::SessionModelAssociator* associator = GetModelAssociator();
   // Make sure the associator has been created.
   if (associator) {
-    std::vector<const browser_sync::SyncedSession*> sessions;
+    std::vector<const SyncedSession*> sessions;
     if (associator->GetAllForeignSessions(&sessions)) {
       GetSessionList(sessions, &session_list);
       CreateMagicTabList(sessions, &magic_list);
     }
   }
 
   // Send the results to JavaScript, even if the lists are empty, so that the
   // UI can show a message that there is nothing.
   web_ui_->CallJavascriptFunction("updateSessionList",
                                   session_list,
@@ skipping 15 matching lines @@
   Profile* profile = Profile::FromBrowserContext(contents->browser_context());
   profile->GetChromeURLDataManager()->AddDataSource(
       CreateSessionsUIHTMLSource());
 }
 
 // static
 RefCountedMemory* SessionsUI::GetFaviconResourceBytes() {
   return ResourceBundle::GetSharedInstance().
       LoadDataResourceBytes(IDR_HISTORY_FAVICON);
 }