NTP5: Starting implementation of a native menu for showing other device sessions.

chrome/browser/ui/webui/ntp/foreign_session_handler.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/i18n/time_formatting.h"
 #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/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
+#include "chrome/browser/ui/search/other_device_menu_controller.h"
 #include "chrome/browser/ui/webui/ntp/new_tab_ui.h"
 #include "chrome/browser/ui/webui/session_favicon_source.h"
 #include "chrome/browser/ui/webui/web_ui_util.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/time_format.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
-#include "content/public/browser/web_ui.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace browser_sync {
 
-// Maximum number of session we're going to display on the NTP
+// Maximum number of sessions we're going to display on the NTP
 static const size_t kMaxSessionsToShow = 10;
 
-// Invalid value, used to note that we don't have a tab or window number.
-static const int kInvalidId = -1;
-
 namespace {
 
 // Comparator function for use with std::sort that will sort sessions by
 // descending modified_time (i.e., most recent first).
 bool SortSessionsByRecency(const SyncedSession* s1, const SyncedSession* s2) {
   return s1->modified_time > s2->modified_time;
 }
 
 }  // namepace
 
 ForeignSessionHandler::ForeignSessionHandler() {
 }
 
 // static
 void ForeignSessionHandler::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(prefs::kNtpCollapsedForeignSessions,
                                 PrefService::UNSYNCABLE_PREF);
 }
 
+// static
+void ForeignSessionHandler::OpenForeignSession(
+    content::WebUI* web_ui,
+    const std::string& session_string_value,
+    SessionID::id_type window_num,
+    SessionID::id_type tab_id,
+    const WindowOpenDisposition& disposition) {
+
+  SessionModelAssociator* associator = GetModelAssociator(web_ui);
+  if (!associator)
+    return;
+
+  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;
+    }
+    if (tab->navigations.empty()) {
+      LOG(ERROR) << "Foreign tab no longer has valid navigations.";
+      return;
+    }
+    SessionRestore::RestoreForeignSessionTab(
+        web_ui->GetWebContents(), *tab, disposition);
+    return;
+  }
+
+  std::vector<const 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<const SessionWindow*>::const_iterator iter_begin =
+      windows.begin() + (window_num == kInvalidId ? 0 : window_num);
+  std::vector<const SessionWindow*>::const_iterator iter_end =
+      window_num == kInvalidId ?
+      std::vector<const SessionWindow*>::const_iterator(windows.end()) :
+      iter_begin + 1;
+  SessionRestore::RestoreForeignSessionWindows(
+      Profile::FromWebUI(web_ui), iter_begin, iter_end);
+}
+
+// static
+bool ForeignSessionHandler::SessionTabToValue(
+    const SessionTab& tab,
+    DictionaryValue* dictionary) {
+  if (tab.navigations.empty())
+    return false;
+
+  int selected_index = std::min(tab.current_navigation_index,
+                                static_cast<int>(tab.navigations.size() - 1));
+  const TabNavigation& current_navigation =
+      tab.navigations.at(selected_index);
+  GURL tab_url = current_navigation.virtual_url();
+  if (tab_url == GURL(chrome::kChromeUINewTabURL))
+    return false;
+
+  NewTabUI::SetUrlTitleAndDirection(dictionary, current_navigation.title(),
+                                    tab_url);
+  dictionary->SetString("type", "tab");
+  dictionary->SetDouble("timestamp",
+                        static_cast<double>(tab.timestamp.ToInternalValue()));
+  // TODO(jeremycho): This should probably be renamed to tabId to avoid
+  // confusion with the ID corresponding to a session.  Investigate all the
+  // places (C++ and JS) where this is being used.  (http://crbug.com/154865).
+  dictionary->SetInteger("sessionId", tab.tab_id.id());
+  return true;
+}
+
+// static
+SessionModelAssociator* ForeignSessionHandler::GetModelAssociator(
+    content::WebUI* web_ui) {
+  Profile* profile = Profile::FromWebUI(web_ui);
+  ProfileSyncService* service =
+      ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile);
+
+  // Only return the associator if it exists and it is done syncing sessions.
+  if (service && service->ShouldPushChanges())
+    return service->GetSessionModelAssociator();
+
+  return NULL;
+}
+
 void ForeignSessionHandler::RegisterMessages() {
   Init();
   web_ui()->RegisterMessageCallback("getForeignSessions",
       base::Bind(&ForeignSessionHandler::HandleGetForeignSessions,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("openForeignSession",
       base::Bind(&ForeignSessionHandler::HandleOpenForeignSession,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("setForeignSessionCollapsed",
       base::Bind(&ForeignSessionHandler::HandleSetForeignSessionCollapsed,
@@ skipping 33 matching lines @@
       // Fall through.
     case chrome::NOTIFICATION_SYNC_CONFIGURE_DONE:
     case chrome::NOTIFICATION_FOREIGN_SESSION_UPDATED:
       HandleGetForeignSessions(&list_value);
       break;
     default:
       NOTREACHED();
   }
 }
 
-SessionModelAssociator* ForeignSessionHandler::GetModelAssociator() {
-  Profile* profile = Profile::FromWebUI(web_ui());
-  ProfileSyncService* service =
-      ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile);
-
-  // Only return the associator if it exists and it is done syncing sessions.
-  if (service && service->ShouldPushChanges())
-    return service->GetSessionModelAssociator();
-
-  return NULL;
-}
 
 bool ForeignSessionHandler::IsTabSyncEnabled() {
   Profile* profile = Profile::FromWebUI(web_ui());
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile);
   return service && service->GetPreferredDataTypes().Has(syncer::SESSIONS);
 }
 
 string16 ForeignSessionHandler::FormatSessionTime(const base::Time& time) {
   // Return a time like "1 hour ago", "2 days ago", etc.
   return TimeFormat::TimeElapsed(base::Time::Now() - time);
 }
 
 void ForeignSessionHandler::HandleGetForeignSessions(const ListValue* args) {
-  SessionModelAssociator* associator = GetModelAssociator();
+  SessionModelAssociator* associator = GetModelAssociator(web_ui());
   std::vector<const SyncedSession*> sessions;
 
   ListValue session_list;
   if (associator && associator->GetAllForeignSessions(&sessions)) {
     // Sort sessions from most recent to least recent.
     std::sort(sessions.begin(), sessions.end(), SortSessionsByRecency);
 
     // Use a pref to keep track of sessions that were collapsed by the user.
     // To prevent the pref from accumulating stale sessions, clear it each time
     // and only add back sessions that are still current.
@@ skipping 70 matching lines @@
 
   // Extract tab id.
   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();
-  if (!associator)
-    return;
+  WindowOpenDisposition disposition =
+      web_ui_util::GetDispositionFromClick(args, 3);
 
-  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;
-    }
-    if (tab->navigations.size() == 0) {
-      LOG(ERROR) << "Foreign tab no longer has valid navigations.";
-      return;
-    }
-    WindowOpenDisposition disposition =
-        web_ui_util::GetDispositionFromClick(args, 3);
-    SessionRestore::RestoreForeignSessionTab(
-        web_ui()->GetWebContents(), *tab, disposition);
-  } else {
-    std::vector<const 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<const SessionWindow*>::const_iterator iter_begin =
-        windows.begin() + ((window_num == kInvalidId) ? 0 : window_num);
-    std::vector<const SessionWindow*>::const_iterator iter_end =
-        ((window_num == kInvalidId) ?
-        std::vector<const SessionWindow*>::const_iterator(windows.end()) :
-        iter_begin + 1);
-    SessionRestore::RestoreForeignSessionWindows(
-        Profile::FromWebUI(web_ui()), iter_begin, iter_end);
-  }
+  OpenForeignSession(
+      web_ui(), session_string_value, window_num, tab_id, disposition);
 }
 
 void ForeignSessionHandler::HandleSetForeignSessionCollapsed(
     const ListValue* args) {
   if (args->GetSize() != 2U) {
     LOG(ERROR) << "Wrong number of args to setForeignSessionCollapsed";
     return;
   }
 
   // Get the session tag argument (required).
@@ skipping 20 matching lines @@
 }
 
 void ForeignSessionHandler::HandleShowOtherDeviceSessionPopup(
     const ListValue* args) {
   CHECK(args->GetSize() == 3U);
 
   // Extract the session tag.
   std::string session_string_value;
   CHECK(args->GetString(0, &session_string_value));
 
-  // Extract horizontal coordinate of the click within the application's client
-  // area.
-  double client_x;
-  CHECK(args->GetDouble(1, &client_x));
+  // Extract horizontal coordinate of the click relative to the origin of the
+  // screen coordinate system.
+  double screen_x;
+  CHECK(args->GetDouble(1, &screen_x));
 
-  // Extract vertical coordinate of the click within the application's client
-  // area.
-  double client_y;
-  CHECK(args->GetDouble(2, &client_y));
-
-  // TODO(vadimt): implement this method.
-}
-
-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(
-      0,
-      std::min(selected_index,
-               static_cast<int>(tab.navigations.size() - 1)));
-  const TabNavigation& current_navigation =
-      tab.navigations.at(selected_index);
-  GURL tab_url = current_navigation.virtual_url();
-  if (tab_url == GURL(chrome::kChromeUINewTabURL))
-    return false;
-  NewTabUI::SetUrlTitleAndDirection(dictionary, current_navigation.title(),
-                                    tab_url);
-  dictionary->SetString("type", "tab");
-  dictionary->SetDouble("timestamp",
-                        static_cast<double>(tab.timestamp.ToInternalValue()));
-  dictionary->SetInteger("sessionId", tab.tab_id.id());
-  return true;
+  // Extract vertical coordinate of the click relative to the origin of the
+  // screen coordinate system.
+  double screen_y;
+  CHECK(args->GetDouble(2, &screen_y));
+  OtherDeviceMenuController* menu = new OtherDeviceMenuController(
+      web_ui(),
+      session_string_value, gfx::Point(screen_x, screen_y));
+    menu->ShowMenu();

[Evan Stade, 2012/10/24 22:51:34]

wrong indent

[jeremycho, 2012/10/24 23:54:41]

Done.

 }
 
 bool ForeignSessionHandler::SessionWindowToValue(
     const SessionWindow& window,
     DictionaryValue* dictionary) {
   if (window.tabs.empty()) {
     NOTREACHED();
     return false;
   }
   scoped_ptr<ListValue> tab_values(new ListValue());
@@ skipping 17 matching lines @@
   dictionary->SetString("userVisibleTimestamp",
       last_synced < base::TimeDelta::FromMinutes(1) ?
           l10n_util::GetStringUTF16(IDS_SYNC_TIME_JUST_NOW) :
           TimeFormat::TimeElapsed(last_synced));
   dictionary->SetInteger("sessionId", window.window_id.id());
   dictionary->Set("tabs", tab_values.release());
   return true;
 }
 
 }  // namespace browser_sync