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"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/ui/webui/ntp/new_tab_ui.h"
 #include "chrome/common/chrome_notification_types.h"
+#include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_service.h"
 #include "chrome/common/url_constants.h"
 
 namespace browser_sync {
 
 // Maximum number of session we're going to display on the NTP
 static const int kMaxSessionsToShow = 10;
 
 // Invalid value, used to note that we don't have a tab or window number.
@@ skipping 34 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();
+  Profile* profile =
+      Profile::FromBrowserContext(web_ui_->tab_contents()->browser_context());
+  ProfileSyncService* service = profile->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::FromBrowserContext(web_ui_->tab_contents()->browser_context());
   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