chrome/browser/android/foreign_session_helper.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/android/foreign_session_helper.h"
   6
   7 #include <jni.h>
   8
   9 #include "base/android/jni_string.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/prefs/scoped_user_pref_update.h"
  12 #include "chrome/browser/android/tab_android.h"
  13 #include "chrome/browser/chrome_notification_types.h"
  14 #include "chrome/browser/profiles/profile_android.h"
  15 #include "chrome/browser/sessions/session_restore.h"
  16 #include "chrome/browser/sync/open_tabs_ui_delegate.h"
  17 #include "chrome/browser/sync/profile_sync_service.h"
  18 #include "chrome/browser/sync/profile_sync_service_factory.h"
  19 #include "chrome/browser/ui/android/tab_model/tab_model.h"
  20 #include "chrome/browser/ui/android/tab_model/tab_model_list.h"
  21 #include "chrome/common/pref_names.h"
  22 #include "chrome/common/url_constants.h"
  23 #include "content/public/browser/notification_source.h"
  24 #include "content/public/browser/web_contents.h"
  25 #include "jni/ForeignSessionHelper_jni.h"
  26
  27 using base::android::ScopedJavaGlobalRef;
  28 using base::android::ScopedJavaLocalRef;
  29 using base::android::AttachCurrentThread;
  30 using base::android::ConvertUTF16ToJavaString;
  31 using base::android::ConvertUTF8ToJavaString;
  32 using base::android::ConvertJavaStringToUTF8;
  33 using browser_sync::OpenTabsUIDelegate;
  34 using browser_sync::SyncedSession;
  35
  36 namespace {
  37
  38 OpenTabsUIDelegate* GetOpenTabsUIDelegate(Profile* profile) {
  39   ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()->
  40       GetForProfile(profile);
  41
  42   // Only return the delegate if it exists and it is done syncing sessions.
  43   if (!service || !service->ShouldPushChanges())
  44     return NULL;
  45
  46   return service->GetOpenTabsUIDelegate();
  47 }
  48
  49 bool ShouldSkipTab(const SessionTab& session_tab) {
  50     if (session_tab.navigations.empty())
  51       return true;
  52
  53     int selected_index = session_tab.current_navigation_index;
  54     if (selected_index < 0 ||
  55         selected_index >= static_cast<int>(session_tab.navigations.size()))
  56       return true;
  57
  58     const ::sessions::SerializedNavigationEntry& current_navigation =
  59         session_tab.navigations.at(selected_index);
  60
  61     if (current_navigation.virtual_url().is_empty())
  62       return true;
  63
  64     return false;
  65 }
  66
  67 bool ShouldSkipWindow(const SessionWindow& window) {
  68   for (std::vector<SessionTab*>::const_iterator tab_it = window.tabs.begin();
  69       tab_it != window.tabs.end(); ++tab_it) {
  70     const SessionTab &session_tab = **tab_it;
  71     if (!ShouldSkipTab(session_tab))
  72       return false;
  73   }
  74   return true;
  75 }
  76
  77 bool ShouldSkipSession(const browser_sync::SyncedSession& session) {
  78   for (SyncedSession::SyncedWindowMap::const_iterator it =
  79       session.windows.begin(); it != session.windows.end(); ++it) {
  80     const SessionWindow  &window = *(it->second);
  81     if (!ShouldSkipWindow(window))
  82       return false;
  83   }
  84   return true;
  85 }
  86
  87 void CopyTabsToJava(
  88     JNIEnv* env,
  89     const SessionWindow& window,
  90     ScopedJavaLocalRef<jobject>& j_window) {
  91   for (std::vector<SessionTab*>::const_iterator tab_it = window.tabs.begin();
  92       tab_it != window.tabs.end(); ++tab_it) {
  93     const SessionTab &session_tab = **tab_it;
  94
  95     if (ShouldSkipTab(session_tab))
  96       continue;
  97
  98     int selected_index = session_tab.current_navigation_index;
  99     DCHECK(selected_index >= 0);
 100     DCHECK(selected_index < static_cast<int>(session_tab.navigations.size()));
 101
 102     const ::sessions::SerializedNavigationEntry& current_navigation =
 103         session_tab.navigations.at(selected_index);
 104
 105     GURL tab_url = current_navigation.virtual_url();
 106
 107     Java_ForeignSessionHelper_pushTab(
 108         env, j_window.obj(),
 109         ConvertUTF8ToJavaString(env, tab_url.spec()).obj(),
 110         ConvertUTF16ToJavaString(env, current_navigation.title()).obj(),
 111         session_tab.timestamp.ToJavaTime(),
 112         session_tab.tab_id.id());
 113   }
 114 }
 115
 116 void CopyWindowsToJava(
 117     JNIEnv* env,
 118     const SyncedSession& session,
 119     ScopedJavaLocalRef<jobject>& j_session) {
 120   for (SyncedSession::SyncedWindowMap::const_iterator it =
 121       session.windows.begin(); it != session.windows.end(); ++it) {
 122     const SessionWindow &window = *(it->second);
 123
 124     if (ShouldSkipWindow(window))
 125       continue;
 126
 127     ScopedJavaLocalRef<jobject> last_pushed_window;
 128     last_pushed_window.Reset(
 129         Java_ForeignSessionHelper_pushWindow(
 130             env, j_session.obj(),
 131             window.timestamp.ToJavaTime(),
 132             window.window_id.id()));
 133
 134     CopyTabsToJava(env, window, last_pushed_window);
 135   }
 136 }
 137
 138 }  // namespace
 139
 140 static jlong Init(JNIEnv* env, jclass clazz, jobject profile) {
 141   ForeignSessionHelper* foreign_session_helper = new ForeignSessionHelper(
 142       ProfileAndroid::FromProfileAndroid(profile));
 143   return reinterpret_cast<intptr_t>(foreign_session_helper);
 144 }
 145
 146 ForeignSessionHelper::ForeignSessionHelper(Profile* profile)
 147     : profile_(profile) {
 148   ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()->
 149       GetForProfile(profile);
 150   registrar_.Add(this, chrome::NOTIFICATION_SYNC_CONFIGURE_DONE,
 151                  content::Source<ProfileSyncService>(service));
 152   registrar_.Add(this, chrome::NOTIFICATION_FOREIGN_SESSION_UPDATED,
 153                  content::Source<Profile>(profile));
 154   registrar_.Add(this, chrome::NOTIFICATION_FOREIGN_SESSION_DISABLED,
 155                  content::Source<Profile>(profile));
 156 }
 157
 158 ForeignSessionHelper::~ForeignSessionHelper() {
 159 }
 160
 161 void ForeignSessionHelper::Destroy(JNIEnv* env, jobject obj) {
 162   delete this;
 163 }
 164
 165 jboolean ForeignSessionHelper::IsTabSyncEnabled(JNIEnv* env, jobject obj) {
 166   ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()->
 167       GetForProfile(profile_);
 168   return service && service->GetActiveDataTypes().Has(syncer::PROXY_TABS);
 169 }
 170
 171 void ForeignSessionHelper::SetOnForeignSessionCallback(JNIEnv* env,
 172                                                        jobject obj,
 173                                                        jobject callback) {
 174   callback_.Reset(env, callback);
 175 }
 176
 177 void ForeignSessionHelper::Observe(
 178     int type, const content::NotificationSource& source,
 179     const content::NotificationDetails& details) {
 180   if (callback_.is_null())
 181     return;
 182
 183   JNIEnv* env = AttachCurrentThread();
 184
 185   switch (type) {
 186     case chrome::NOTIFICATION_FOREIGN_SESSION_DISABLED:
 187       // Tab sync is disabled, so clean up data about collapsed sessions.
 188       profile_->GetPrefs()->ClearPref(
 189           prefs::kNtpCollapsedForeignSessions);
 190       // Purposeful fall through.
 191     case chrome::NOTIFICATION_SYNC_CONFIGURE_DONE:
 192     case chrome::NOTIFICATION_FOREIGN_SESSION_UPDATED:
 193       Java_ForeignSessionCallback_onUpdated(env, callback_.obj());
 194       break;
 195     default:
 196       NOTREACHED();
 197   }
 198 }
 199
 200 jboolean ForeignSessionHelper::GetForeignSessions(JNIEnv* env,
 201                                                   jobject obj,
 202                                                   jobject result) {
 203   OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate(profile_);
 204   if (!open_tabs)
 205     return false;
 206
 207   std::vector<const browser_sync::SyncedSession*> sessions;
 208   if (!open_tabs->GetAllForeignSessions(&sessions))
 209     return false;
 210
 211   // Use a pref to keep track of sessions that were collapsed by the user.
 212   // To prevent the pref from accumulating stale sessions, clear it each time
 213   // and only add back sessions that are still current.
 214   DictionaryPrefUpdate pref_update(profile_->GetPrefs(),
 215                                    prefs::kNtpCollapsedForeignSessions);
 216   base::DictionaryValue* pref_collapsed_sessions = pref_update.Get();
 217   scoped_ptr<base::DictionaryValue> collapsed_sessions(
 218       pref_collapsed_sessions->DeepCopy());
 219   pref_collapsed_sessions->Clear();
 220
 221   ScopedJavaLocalRef<jobject> last_pushed_session;
 222   ScopedJavaLocalRef<jobject> last_pushed_window;
 223
 224   // Note: we don't own the SyncedSessions themselves.
 225   for (size_t i = 0; i < sessions.size(); ++i) {
 226     const browser_sync::SyncedSession &session = *(sessions[i]);
 227     if (ShouldSkipSession(session))
 228       continue;
 229
 230     const bool is_collapsed = collapsed_sessions->HasKey(session.session_tag);
 231
 232     if (is_collapsed)
 233       pref_collapsed_sessions->SetBoolean(session.session_tag, true);
 234
 235     last_pushed_session.Reset(
 236         Java_ForeignSessionHelper_pushSession(
 237             env,
 238             result,
 239             ConvertUTF8ToJavaString(env, session.session_tag).obj(),
 240             ConvertUTF8ToJavaString(env, session.session_name).obj(),
 241             session.device_type,
 242             session.modified_time.ToJavaTime()));
 243
 244     CopyWindowsToJava(env, session, last_pushed_session);
 245   }
 246
 247   return true;
 248 }
 249
 250 jboolean ForeignSessionHelper::OpenForeignSessionTab(JNIEnv* env,
 251                                                      jobject obj,
 252                                                      jobject j_tab,
 253                                                      jstring session_tag,
 254                                                      jint session_tab_id,
 255                                                      jint j_disposition) {
 256   OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate(profile_);
 257   if (!open_tabs) {
 258     LOG(ERROR) << "Null OpenTabsUIDelegate returned.";
 259     return false;
 260   }
 261
 262   const SessionTab* session_tab;
 263
 264   if (!open_tabs->GetForeignTab(ConvertJavaStringToUTF8(env, session_tag),
 265                                 session_tab_id,
 266                                 &session_tab)) {
 267     LOG(ERROR) << "Failed to load foreign tab.";
 268     return false;
 269   }
 270
 271   if (session_tab->navigations.empty()) {
 272     LOG(ERROR) << "Foreign tab no longer has valid navigations.";
 273     return false;
 274   }
 275
 276   TabAndroid* tab_android = TabAndroid::GetNativeTab(env, j_tab);
 277   if (!tab_android)
 278     return false;
 279   content::WebContents* web_contents = tab_android->web_contents();
 280   if (!web_contents)
 281     return false;
 282
 283   WindowOpenDisposition disposition =
 284       static_cast<WindowOpenDisposition>(j_disposition);
 285   SessionRestore::RestoreForeignSessionTab(web_contents,
 286                                            *session_tab,
 287                                            disposition);
 288
 289   return true;
 290 }
 291
 292 void ForeignSessionHelper::DeleteForeignSession(JNIEnv* env, jobject obj,
 293                                                 jstring session_tag) {
 294   OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate(profile_);
 295   if (open_tabs)
 296     open_tabs->DeleteForeignSession(ConvertJavaStringToUTF8(env, session_tag));
 297 }
 298
 299 // static
 300 bool ForeignSessionHelper::RegisterForeignSessionHelper(JNIEnv* env) {
 301   return RegisterNativesImpl(env);
 302 }