Foreign session pages now load into current tab.

chrome/browser/android/foreign_session_helper.cc

 // Copyright 2013 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/android/foreign_session_helper.h"
 
 #include <jni.h>
 
 #include "base/android/jni_string.h"
+#include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
+#include "chrome/browser/android/tab_android.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile_android.h"
+#include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sync/glue/session_model_associator.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/android/tab_model/tab_model.h"
 #include "chrome/browser/ui/android/tab_model/tab_model_list.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 #include "jni/ForeignSessionHelper_jni.h"
@@ skipping 13 matching lines @@
   ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()->
       GetForProfile(profile);
 
   // Only return the associator if it exists and it is done syncing sessions.
   if (!service || !service->ShouldPushChanges())
     return NULL;
 
   return service->GetSessionModelAssociator();
 }
 
-bool ShouldSkipTab(const SessionTab& tab) {
-    if (tab.navigations.empty())
+bool ShouldSkipTab(const SessionTab& session_tab) {
+    if (session_tab.navigations.empty())
       return true;
 
-    int selected_index = tab.current_navigation_index;
+    int selected_index = session_tab.current_navigation_index;
     if (selected_index < 0 ||
-        selected_index >= static_cast<int>(tab.navigations.size()))
+        selected_index >= static_cast<int>(session_tab.navigations.size()))
       return true;
 
     const ::sessions::SerializedNavigationEntry& current_navigation =
-        tab.navigations.at(selected_index);
+        session_tab.navigations.at(selected_index);
 
     if (current_navigation.virtual_url().is_empty())
       return true;
 
     return false;
 }
 
 bool ShouldSkipWindow(const SessionWindow& window) {
   for (std::vector<SessionTab*>::const_iterator tab_it = window.tabs.begin();
       tab_it != window.tabs.end(); ++tab_it) {
-    const SessionTab &tab = **tab_it;
-    if (!ShouldSkipTab(tab))
+    const SessionTab &session_tab = **tab_it;
+    if (!ShouldSkipTab(session_tab))
       return false;
   }
   return true;
 }
 
 bool ShouldSkipSession(const browser_sync::SyncedSession& session) {
   for (SyncedSession::SyncedWindowMap::const_iterator it =
       session.windows.begin(); it != session.windows.end(); ++it) {
     const SessionWindow  &window = *(it->second);
     if (!ShouldSkipWindow(window))
       return false;
   }
   return true;
 }
 
 void CopyTabsToJava(
     JNIEnv* env,
     const SessionWindow& window,
     ScopedJavaLocalRef<jobject>& j_window) {
   for (std::vector<SessionTab*>::const_iterator tab_it = window.tabs.begin();
       tab_it != window.tabs.end(); ++tab_it) {
-    const SessionTab &tab = **tab_it;
+    const SessionTab &session_tab = **tab_it;
 
-    if (ShouldSkipTab(tab))
+    if (ShouldSkipTab(session_tab))
       continue;
 
-    int selected_index = tab.current_navigation_index;
+    int selected_index = session_tab.current_navigation_index;
     DCHECK(selected_index >= 0);
-    DCHECK(selected_index < static_cast<int>(tab.navigations.size()));
+    DCHECK(selected_index < static_cast<int>(session_tab.navigations.size()));
 
     const ::sessions::SerializedNavigationEntry& current_navigation =
-        tab.navigations.at(selected_index);
+        session_tab.navigations.at(selected_index);
 
     GURL tab_url = current_navigation.virtual_url();
 
     Java_ForeignSessionHelper_pushTab(
         env, j_window.obj(),
         ConvertUTF8ToJavaString(env, tab_url.spec()).Release(),
         ConvertUTF16ToJavaString(env, current_navigation.title()).Release(),
-        tab.timestamp.ToJavaTime(),
-        tab.tab_id.id());
+        session_tab.timestamp.ToJavaTime(),
+        session_tab.tab_id.id());
   }
 }
 
 void CopyWindowsToJava(
     JNIEnv* env,
     const SyncedSession& session,
     ScopedJavaLocalRef<jobject>& j_session) {
   for (SyncedSession::SyncedWindowMap::const_iterator it =
       session.windows.begin(); it != session.windows.end(); ++it) {
     const SessionWindow &window = *(it->second);
@@ skipping 117 matching lines @@
             ConvertUTF8ToJavaString(env, session.session_name).Release(),
             session.device_type,
             session.modified_time.ToJavaTime()));
 
     CopyWindowsToJava(env, session, last_pushed_session);
   }
 
   return true;
 }
 
-jboolean ForeignSessionHelper::OpenForeignSessionTab(JNIEnv* env,
-                                                     jobject obj,
-                                                     jstring session_tag,
-                                                     jint tab_id) {
+// TODO(apiccion): Remvoe this method once downstream CL Lands.
+// See: http://crbug.com/257102
+jboolean ForeignSessionHelper::OpenForeignSessionTabOld(JNIEnv* env,
+                                                        jobject obj,
+                                                        jstring session_tag,
+                                                        jint session_tab_id) {
   SessionModelAssociator* associator = GetSessionModelAssociator(profile_);
   if (!associator) {
     LOG(ERROR) << "Null SessionModelAssociator returned.";
     return false;
   }
 
-  const SessionTab* tab;
+  const SessionTab* session_tab;
 
   if (!associator->GetForeignTab(ConvertJavaStringToUTF8(env, session_tag),
-                                 tab_id, &tab)) {
+                                 session_tab_id, &session_tab)) {
     LOG(ERROR) << "Failed to load foreign tab.";
     return false;
   }
 
-  if (tab->navigations.empty()) {
+  if (session_tab->navigations.empty()) {
     LOG(ERROR) << "Foreign tab no longer has valid navigations.";
     return false;
   }
 
   TabModel* tab_model = TabModelList::GetTabModelWithProfile(profile_);
   DCHECK(tab_model);
   if (!tab_model)
     return false;
 
   std::vector<content::NavigationEntry*> entries =
       sessions::SerializedNavigationEntry::ToNavigationEntries(
-          tab->navigations, profile_);
+          session_tab->navigations, profile_);
   content::WebContents* new_web_contents = content::WebContents::Create(
       content::WebContents::CreateParams(profile_));
-  int selected_index = tab->normalized_navigation_index();
+  int selected_index = session_tab->normalized_navigation_index();
   new_web_contents->GetController().Restore(
       selected_index,
       content::NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY,
       &entries);
   tab_model->CreateTab(new_web_contents);
 
   return true;
 }
 
+jboolean ForeignSessionHelper::OpenForeignSessionTab(JNIEnv* env,
+                                                     jobject obj,
+                                                     jobject j_tab,
+                                                     jstring session_tag,
+                                                     jint session_tab_id,
+                                                     jint j_disposition) {
+  SessionModelAssociator* associator = GetSessionModelAssociator(profile_);
+  if (!associator) {
+    LOG(ERROR) << "Null SessionModelAssociator returned.";
+    return false;
+  }
+
+  const SessionTab* session_tab;
+
+  if (!associator->GetForeignTab(ConvertJavaStringToUTF8(env, session_tag),
+                                 session_tab_id,
+                                 &session_tab)) {
+    LOG(ERROR) << "Failed to load foreign tab.";
+    return false;
+  }
+
+  if (session_tab->navigations.empty()) {
+    LOG(ERROR) << "Foreign tab no longer has valid navigations.";
+    return false;
+  }
+
+  TabAndroid* tab_android = TabAndroid::GetNativeTab(env, j_tab);
+  if (!tab_android)
+    return false;
+  content::WebContents* web_contents = tab_android->web_contents();
+  if (!web_contents)
+    return false;
+
+  WindowOpenDisposition disposition =
+      static_cast<WindowOpenDisposition>(j_disposition);
+  SessionRestore::RestoreForeignSessionTab(web_contents,
+                                           *session_tab,
+                                           disposition);
+
+  return true;
+}
+
 void ForeignSessionHelper::SetForeignSessionCollapsed(JNIEnv* env, jobject obj,
                                                       jstring session_tag,
                                                       jboolean is_collapsed) {
   // Store session tags for collapsed sessions in a preference so that the
   // collapsed state persists.
   PrefService* prefs = profile_->GetPrefs();
   DictionaryPrefUpdate update(prefs, prefs::kNtpCollapsedForeignSessions);
   if (is_collapsed)
     update.Get()->SetBoolean(ConvertJavaStringToUTF8(env, session_tag), true);
   else
@@ skipping 12 matching lines @@
                                                 jstring session_tag) {
   SessionModelAssociator* associator = GetSessionModelAssociator(profile_);
   if (associator)
     associator->DeleteForeignSession(ConvertJavaStringToUTF8(env, session_tag));
 }
 
 // static
 bool ForeignSessionHelper::RegisterForeignSessionHelper(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }