This source file includes following definitions.
- GetOpenTabsUIDelegate
- ShouldSkipTab
- ShouldSkipWindow
- ShouldSkipSession
- CopyTabsToJava
- CopyWindowsToJava
- Init
- Destroy
- IsTabSyncEnabled
- SetOnForeignSessionCallback
- Observe
- GetForeignSessions
- OpenForeignSessionTab
- DeleteForeignSession
- RegisterForeignSessionHelper
#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/open_tabs_ui_delegate.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"
using base::android::ScopedJavaGlobalRef;
using base::android::ScopedJavaLocalRef;
using base::android::AttachCurrentThread;
using base::android::ConvertUTF16ToJavaString;
using base::android::ConvertUTF8ToJavaString;
using base::android::ConvertJavaStringToUTF8;
using browser_sync::OpenTabsUIDelegate;
using browser_sync::SyncedSession;
namespace {
OpenTabsUIDelegate* GetOpenTabsUIDelegate(Profile* profile) {
ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()->
GetForProfile(profile);
if (!service || !service->ShouldPushChanges())
return NULL;
return service->GetOpenTabsUIDelegate();
}
bool ShouldSkipTab(const SessionTab& session_tab) {
if (session_tab.navigations.empty())
return true;
int selected_index = session_tab.current_navigation_index;
if (selected_index < 0 ||
selected_index >= static_cast<int>(session_tab.navigations.size()))
return true;
const ::sessions::SerializedNavigationEntry& current_navigation =
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 &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 &session_tab = **tab_it;
if (ShouldSkipTab(session_tab))
continue;
int selected_index = session_tab.current_navigation_index;
DCHECK(selected_index >= 0);
DCHECK(selected_index < static_cast<int>(session_tab.navigations.size()));
const ::sessions::SerializedNavigationEntry& current_navigation =
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(),
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);
if (ShouldSkipWindow(window))
continue;
ScopedJavaLocalRef<jobject> last_pushed_window;
last_pushed_window.Reset(
Java_ForeignSessionHelper_pushWindow(
env, j_session.obj(),
window.timestamp.ToJavaTime(),
window.window_id.id()));
CopyTabsToJava(env, window, last_pushed_window);
}
}
}
static jlong Init(JNIEnv* env, jclass clazz, jobject profile) {
ForeignSessionHelper* foreign_session_helper = new ForeignSessionHelper(
ProfileAndroid::FromProfileAndroid(profile));
return reinterpret_cast<intptr_t>(foreign_session_helper);
}
ForeignSessionHelper::ForeignSessionHelper(Profile* profile)
: profile_(profile) {
ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()->
GetForProfile(profile);
registrar_.Add(this, chrome::NOTIFICATION_SYNC_CONFIGURE_DONE,
content::Source<ProfileSyncService>(service));
registrar_.Add(this, chrome::NOTIFICATION_FOREIGN_SESSION_UPDATED,
content::Source<Profile>(profile));
registrar_.Add(this, chrome::NOTIFICATION_FOREIGN_SESSION_DISABLED,
content::Source<Profile>(profile));
}
ForeignSessionHelper::~ForeignSessionHelper() {
}
void ForeignSessionHelper::Destroy(JNIEnv* env, jobject obj) {
delete this;
}
jboolean ForeignSessionHelper::IsTabSyncEnabled(JNIEnv* env, jobject obj) {
ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()->
GetForProfile(profile_);
return service && service->GetActiveDataTypes().Has(syncer::PROXY_TABS);
}
void ForeignSessionHelper::SetOnForeignSessionCallback(JNIEnv* env,
jobject obj,
jobject callback) {
callback_.Reset(env, callback);
}
void ForeignSessionHelper::Observe(
int type, const content::NotificationSource& source,
const content::NotificationDetails& details) {
if (callback_.is_null())
return;
JNIEnv* env = AttachCurrentThread();
switch (type) {
case chrome::NOTIFICATION_FOREIGN_SESSION_DISABLED:
profile_->GetPrefs()->ClearPref(
prefs::kNtpCollapsedForeignSessions);
case chrome::NOTIFICATION_SYNC_CONFIGURE_DONE:
case chrome::NOTIFICATION_FOREIGN_SESSION_UPDATED:
Java_ForeignSessionCallback_onUpdated(env, callback_.obj());
break;
default:
NOTREACHED();
}
}
jboolean ForeignSessionHelper::GetForeignSessions(JNIEnv* env,
jobject obj,
jobject result) {
OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate(profile_);
if (!open_tabs)
return false;
std::vector<const browser_sync::SyncedSession*> sessions;
if (!open_tabs->GetAllForeignSessions(&sessions))
return false;
DictionaryPrefUpdate pref_update(profile_->GetPrefs(),
prefs::kNtpCollapsedForeignSessions);
base::DictionaryValue* pref_collapsed_sessions = pref_update.Get();
scoped_ptr<base::DictionaryValue> collapsed_sessions(
pref_collapsed_sessions->DeepCopy());
pref_collapsed_sessions->Clear();
ScopedJavaLocalRef<jobject> last_pushed_session;
ScopedJavaLocalRef<jobject> last_pushed_window;
for (size_t i = 0; i < sessions.size(); ++i) {
const browser_sync::SyncedSession &session = *(sessions[i]);
if (ShouldSkipSession(session))
continue;
const bool is_collapsed = collapsed_sessions->HasKey(session.session_tag);
if (is_collapsed)
pref_collapsed_sessions->SetBoolean(session.session_tag, true);
last_pushed_session.Reset(
Java_ForeignSessionHelper_pushSession(
env,
result,
ConvertUTF8ToJavaString(env, session.session_tag).Release(),
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,
jobject j_tab,
jstring session_tag,
jint session_tab_id,
jint j_disposition) {
OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate(profile_);
if (!open_tabs) {
LOG(ERROR) << "Null OpenTabsUIDelegate returned.";
return false;
}
const SessionTab* session_tab;
if (!open_tabs->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::DeleteForeignSession(JNIEnv* env, jobject obj,
jstring session_tag) {
OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate(profile_);
if (open_tabs)
open_tabs->DeleteForeignSession(ConvertJavaStringToUTF8(env, session_tag));
}
bool ForeignSessionHelper::RegisterForeignSessionHelper(JNIEnv* env) {
return RegisterNativesImpl(env);
}