Shortcut ctrl+shift+T added on android.

chrome/browser/ui/android/tab_model/android_live_tab_context.cc

Index: chrome/browser/ui/android/tab_model/android_live_tab_context.cc
diff --git a/chrome/browser/ui/android/tab_model/android_live_tab_context.cc b/chrome/browser/ui/android/tab_model/android_live_tab_context.cc
new file mode 100644
index 0000000000000000000000000000000000000000..91acef6f6739b36e3029c85403bcff6c1bdaea2d
--- /dev/null
+++ b/chrome/browser/ui/android/tab_model/android_live_tab_context.cc
@@ -0,0 +1,139 @@
+// Copyright 2016 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/tab_android.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/android/tab_model/android_live_tab_context.h"
+#include "chrome/browser/ui/android/tab_model/tab_model.h"
+#include "chrome/browser/ui/android/tab_model/tab_model_list.h"
+#include "components/sessions/content/content_live_tab.h"
+#include "components/sessions/content/content_serialized_navigation_builder.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/navigation_entry.h"
+
+// TODO(xingliu): add unit test for this class.
+AndroidLiveTabContext::AndroidLiveTabContext(TabModel* tab_model)
+    : tab_model_(tab_model) {}
+
+// Not supported by android.
+void AndroidLiveTabContext::ShowBrowserWindow() {

[Theresa, 2016/07/12 00:06:16]

nit: Let's add NotReached() here so we crashes if this method is called.

[xingliu, 2016/07/12 03:57:18]

This will be called by android. Since we wired in to that part of the code in
tab_restore_service_helper.cc.

Didn't implement this because that function is like show certain window, where
android doesn't quite have this feature.

[Theresa, 2016/07/12 17:25:16]

Ah, okay. Then instead of saying "Not supported by Android." let's say something
like:

void AndroidLiveTabContext::ShowBrowserWindow() {
  // Intentionally empty. This method is called during restoration of closed
tabs, but is not expected to do anything on Android.

}

+}
+
+const SessionID& AndroidLiveTabContext::GetSessionID() const {
+  return tab_model_->SessionId();
+}
+
+int AndroidLiveTabContext::GetTabCount() const {
+  return tab_model_->GetTabCount();
+}
+
+int AndroidLiveTabContext::GetSelectedIndex() const {
+  return tab_model_->GetActiveIndex();
+}
+
+// Not supported by android.
+std::string AndroidLiveTabContext::GetAppName() const {
+  return std::string();
+}
+
+sessions::LiveTab* AndroidLiveTabContext::GetLiveTabAt(int index) const {
+  TabAndroid* tab_android = tab_model_->GetTabAt(index);
+  if (!tab_android || !tab_android->web_contents())
+    return nullptr;
+
+  return sessions::ContentLiveTab::GetForWebContents(
+      tab_android->web_contents());
+}
+
+sessions::LiveTab* AndroidLiveTabContext::GetActiveLiveTab() const {
+  content::WebContents* web_contents = tab_model_->GetActiveWebContents();
+  if (!web_contents)
+    return nullptr;
+
+  return sessions::ContentLiveTab::GetForWebContents(web_contents);
+}
+
+// Not supported by android.
+bool AndroidLiveTabContext::IsTabPinned(int index) const {
+  return false;
+}
+
+sessions::LiveTab* AndroidLiveTabContext::AddRestoredTab(
+    const std::vector<sessions::SerializedNavigationEntry>& navigations,
+    int tab_index,
+    int selected_navigation,
+    const std::string& extension_app_id,
+    bool select,
+    bool pin,
+    bool from_last_session,
+    const sessions::PlatformSpecificTabData* tab_platform_data,
+    const std::string& user_agent_override) {
+  Profile* profile = tab_model_->GetProfile();
+
+  // Prepare navigation history.
+  std::vector<std::unique_ptr<content::NavigationEntry>> nav_entries =
+        sessions::ContentSerializedNavigationBuilder::ToNavigationEntries(
+            navigations, profile);
+
+  // Restore web contents with navigation history.
+  content::WebContents* web_contents = content::WebContents::Create(
+          content::WebContents::CreateParams(profile));
+  web_contents->GetController().Restore(
+      selected_navigation,
+      content::NavigationController::RESTORE_CURRENT_SESSION,
+      &nav_entries);
+
+  // Create new tab.
+  tab_model_->CreateTab(NULL, web_contents, -1);
+  return sessions::ContentLiveTab::GetForWebContents(web_contents);
+}
+
+// Currently does nothing.
+sessions::LiveTab* AndroidLiveTabContext::ReplaceRestoredTab(
+    const std::vector<sessions::SerializedNavigationEntry>& navigations,
+    int selected_navigation,
+    bool from_last_session,
+    const std::string& extension_app_id,
+    const sessions::PlatformSpecificTabData* tab_platform_data,
+    const std::string& user_agent_override) {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+// Currently does nothing.
+void AndroidLiveTabContext::CloseTab() {
+  NOTIMPLEMENTED();
+}
+
+// static.
+sessions::LiveTabContext* AndroidLiveTabContext::FindContextForWebContents(
+    const content::WebContents* contents) {
+  TabAndroid* tab_android = TabAndroid::FromWebContents(contents);
+  if (!tab_android)
+    return nullptr;
+
+  TabModel* model = TabModelList::FindTabModelWithId(
+      tab_android->window_id().id());
+
+  return model ? model->GetLiveTabContext() : nullptr;
+}
+
+// static.
+sessions::LiveTabContext* AndroidLiveTabContext::FindContextWithID(
+    SessionID::id_type desired_id) {
+  // Find the model with desired id.
+  TabModel* model = TabModelList::FindTabModelWithId(desired_id);
+
+  // If we can't find the correct model, fall back to first non-incognito model.
+  if (!model || model->IsOffTheRecord()) {
+    for (auto it = TabModelList::begin(); it != TabModelList::end(); ++it) {
+      TabModel* model = *it;
+      if (!model->IsOffTheRecord()) {
+        return model->GetLiveTabContext();
+      }
+    }
+  }
+
+  return model ? model->GetLiveTabContext() : nullptr;
+}