Removal of Profile from content part 6.

chrome/browser/ui/webui/ntp/foreign_session_handler.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/ntp/foreign_session_handler.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 #include "base/memory/scoped_vector.h"
@@ skipping 53 matching lines @@
       // Calling foreignSessions with empty list will automatically hide
       // foreign session section.
       web_ui_->CallJavascriptFunction("foreignSessions", list_value);
       break;
     default:
       NOTREACHED();
   }
 }
 
 SessionModelAssociator* ForeignSessionHandler::GetModelAssociator() {
-  ProfileSyncService* service = web_ui_->GetProfile()->GetProfileSyncService();
+  ProfileSyncService* service =
+      Profile::FromWebUI(web_ui_)->GetProfileSyncService();
   if (service == NULL)
     return NULL;
+
   // We only want to set the model associator if there is one, and it is done
   // syncing sessions.
-  SessionModelAssociator* model_associator = service->
-      GetSessionModelAssociator();
+  SessionModelAssociator* model_associator =
+      service->GetSessionModelAssociator();
   if (model_associator == NULL ||
       !service->ShouldPushChanges()) {
     return NULL;
   }
-  return web_ui_->GetProfile()->GetProfileSyncService()->
-      GetSessionModelAssociator();
+  return model_associator;
 }
 
 void ForeignSessionHandler::HandleGetForeignSessions(const ListValue* args) {
   SessionModelAssociator* associator = GetModelAssociator();
   std::vector<const SyncedSession*> sessions;
 
   if (associator == NULL) {
     // Called before associator created, exit.
     return;
   }
@@ skipping 60 matching lines @@
   std::string tab_id_str;
   SessionID::id_type tab_id = kInvalidId;
   if (num_args == 3 && (!args->GetString(2, &tab_id_str) ||
       !base::StringToInt(tab_id_str, &tab_id))) {
     LOG(ERROR) << "Failed to extract tab SessionID.";
     return;
   }
 
   SessionModelAssociator* associator = GetModelAssociator();
 
+  Profile* profile = Profile::FromWebUI(web_ui_);
   if (tab_id != kInvalidId) {
     // We don't actually care about |window_num|, this is just a sanity check.
     DCHECK_LT(kInvalidId, window_num);
     const SessionTab* tab;
     if (!associator->GetForeignTab(session_string_value, tab_id, &tab)) {
       LOG(ERROR) << "Failed to load foreign tab.";
       return;
     }
-    SessionRestore::RestoreForeignSessionTab(web_ui_->GetProfile(), *tab);
+    SessionRestore::RestoreForeignSessionTab(profile, *tab);
   } else {
     std::vector<SessionWindow*> windows;
     // Note: we don't own the ForeignSessions themselves.
     if (!associator->GetForeignSession(session_string_value, &windows)) {
       LOG(ERROR) << "ForeignSessionHandler failed to get session data from"
           "SessionModelAssociator.";
       return;
     }
     std::vector<SessionWindow*>::const_iterator iter_begin = windows.begin() +
         ((window_num == kInvalidId) ? 0 : window_num);
     std::vector<SessionWindow*>::const_iterator iter_end =
         ((window_num == kInvalidId) ?
         std::vector<SessionWindow*>::const_iterator(windows.end()) :
-        iter_begin+1);
-    SessionRestore::RestoreForeignSessionWindows(web_ui_->GetProfile(),
-                                                 iter_begin,
-                                                 iter_end);
+        iter_begin + 1);
+    SessionRestore::RestoreForeignSessionWindows(profile, iter_begin, iter_end);
   }
 }
 
 bool ForeignSessionHandler::SessionTabToValue(
     const SessionTab& tab,
     DictionaryValue* dictionary) {
   if (tab.navigations.empty())
     return false;
   int selected_index = tab.current_navigation_index;
   selected_index = std::max(
@@ skipping 30 matching lines @@
     return false;
   dictionary->SetString("type", "window");
   dictionary->SetDouble("timestamp",
       static_cast<double>(window.timestamp.ToInternalValue()));
   dictionary->SetInteger("sessionId", window.window_id.id());
   dictionary->Set("tabs", tab_values.release());
   return true;
 }
 
 }  // namespace browser_sync