[sync] WebContentsObserver based sessions notifications

chrome/browser/sync/test/integration/sessions_helper.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/sync/test/integration/sessions_helper.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
-#include "chrome/browser/sync/sessions/notification_service_sessions_router.h"
 #include "chrome/browser/sync/test/integration/profile_sync_service_harness.h"
 #include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/singleton_tabs.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/sync/driver/sync_client.h"
 #include "components/sync/test/fake_server/fake_server.h"
 #include "components/sync/test/fake_server/sessions_hierarchy.h"
 #include "components/sync_sessions/open_tabs_ui_delegate.h"
 #include "content/public/browser/navigation_entry.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/test/browser_test_utils.cc"
 #include "content/public/test/test_utils.h"
 #include "url/gurl.h"
 
 using sync_datatype_helper::test;
 
 namespace sessions_helper {
 
 bool GetLocalSession(int index, const sync_sessions::SyncedSession** session) {
   return ProfileSyncServiceFactory::GetInstance()
       ->GetForProfile(test()->GetProfile(index))
@@ skipping 45 matching lines @@
 }
 
 bool OpenTab(int index, const GURL& url) {
   DVLOG(1) << "Opening tab: " << url.spec() << " using browser " << index
            << ".";
   return OpenTabAtIndex(index, 0, url);
 }
 
 bool OpenTabAtIndex(int index, int tab_index, const GURL& url) {
   chrome::AddTabAt(test()->GetBrowser(index), url, tab_index, true);
-  return WaitForTabsToLoad(index, {url});
+  return WaitForTabToLoad(
+      index, url,
+      test()->GetBrowser(index)->tab_strip_model()->GetWebContentsAt(
+          tab_index));
 }
 
 bool OpenMultipleTabs(int index, const std::vector<GURL>& urls) {
   Browser* browser = test()->GetBrowser(index);
   for (std::vector<GURL>::const_iterator it = urls.begin();
        it != urls.end(); ++it) {
     DVLOG(1) << "Opening tab: " << it->spec() << " using browser " << index
              << ".";
     chrome::ShowSingletonTab(browser, *it);
   }
   return WaitForTabsToLoad(index, urls);
 }
 
+bool OpenTabFromSourceIndex(int index,
+                            int index_of_source_tab,
+                            const GURL& url,
+                            WindowOpenDisposition disposition) {
+  content::WebContents* source_contents =
+      test()->GetBrowser(index)->tab_strip_model()->GetWebContentsAt(
+          index_of_source_tab);
+
+  content::OpenURLParams open_url_params(url, content::Referrer(), disposition,
+                                         ui::PAGE_TRANSITION_LINK, false,
+                                         false);
+  open_url_params.source_render_frame_id =
+      source_contents->GetMainFrame()->GetRoutingID();
+  open_url_params.source_render_process_id =
+      source_contents->GetRenderProcessHost()->GetID();
+
+  content::WebContents* new_contents =
+      source_contents->OpenURL(open_url_params);
+  if (!new_contents) {
+    return false;
+  }
+
+  return WaitForTabToLoad(index, url, new_contents);
+}
+
 void MoveTab(int from_index, int to_index, int tab_index) {
   content::WebContents* detached_contents =
       test()
           ->GetBrowser(from_index)
           ->tab_strip_model()
           ->DetachWebContentsAt(tab_index);
 
   TabStripModel* target_strip = test()->GetBrowser(to_index)->tab_strip_model();
   target_strip->InsertWebContentsAt(target_strip->count(), detached_contents,
                                     TabStripModel::ADD_ACTIVE);
 }
 
 bool NavigateTab(int index, const GURL& url) {
   chrome::NavigateParams params(test()->GetBrowser(index), url,
                                 ui::PAGE_TRANSITION_LINK);
   params.disposition = WindowOpenDisposition::CURRENT_TAB;
 
   ui_test_utils::NavigateToURL(&params);
-  return WaitForTabsToLoad(index, {url});
+  return WaitForTabToLoad(index, url, params.target_contents);
 }
 
 void NavigateTabBack(int index) {
   test()
       ->GetBrowser(index)
       ->tab_strip_model()
       ->GetWebContentsAt(0)
       ->GetController()
       .GoBack();
 }
 
 void NavigateTabForward(int index) {
   test()
       ->GetBrowser(index)
       ->tab_strip_model()
       ->GetWebContentsAt(0)
       ->GetController()
       .GoForward();
 }
 
-namespace {
+bool WaitForTabsToLoad(int index, const std::vector<GURL>& urls) {
+  int tab_index = 0;
+  for (const auto& url : urls) {
+    bool success = WaitForTabToLoad(
+        index, url,
+        test()->GetBrowser(index)->tab_strip_model()->GetWebContentsAt(
+            tab_index));
+    if (!success) {
+      return false;
+    }
+    tab_index++;
+  }
+  return true;
+}
 
-class TabEventHandler : public sync_sessions::LocalSessionEventHandler {
- public:
-  TabEventHandler() : weak_factory_(this) {
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&TabEventHandler::QuitLoop, weak_factory_.GetWeakPtr()),
-        TestTimeouts::action_max_timeout());
-  }
-
-  void OnLocalTabModified(
-      sync_sessions::SyncedTabDelegate* modified_tab) override {
-    // Unwind to ensure SessionsSyncManager has processed the event.
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::Bind(&TabEventHandler::QuitLoop, weak_factory_.GetWeakPtr()));
-  }
-
-  void OnFaviconsChanged(const std::set<GURL>& /* page_urls */,
-                         const GURL& /* icon_url */) override {
-    // Unwind to ensure SessionsSyncManager has processed the event.
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::Bind(&TabEventHandler::QuitLoop, weak_factory_.GetWeakPtr()));
-  }
-
- private:
-  void QuitLoop() { base::MessageLoop::current()->QuitWhenIdle(); }
-
-  base::WeakPtrFactory<TabEventHandler> weak_factory_;
-};
-
-}  // namespace
-
-bool WaitForTabsToLoad(int index, const std::vector<GURL>& urls) {
+bool WaitForTabToLoad(int index,
+                      const GURL& url,
+                      content::WebContents* web_contents) {
   DVLOG(1) << "Waiting for session to propagate to associator.";
   base::TimeTicks start_time = base::TimeTicks::Now();
   base::TimeTicks end_time = start_time + TestTimeouts::action_max_timeout();
-  bool found;
-  for (std::vector<GURL>::const_iterator it = urls.begin();
-       it != urls.end(); ++it) {
-    found = false;
-    while (!found) {
-      found = ModelAssociatorHasTabWithUrl(index, *it);
-      if (base::TimeTicks::Now() >= end_time) {
-        LOG(ERROR) << "Failed to find all tabs after "
-                   << TestTimeouts::action_max_timeout().InSecondsF()
-                   << " seconds.";
-        return false;
-      }
-      if (!found) {
-        TabEventHandler handler;
-        sync_sessions::NotificationServiceSessionsRouter router(
-            test()->GetProfile(index),
-            ProfileSyncServiceFactory::GetInstance()
-                ->GetForProfile(test()->GetProfile(index))
-                ->GetSyncClient()
-                ->GetSyncSessionsClient(),
-            syncer::SyncableService::StartSyncFlare());
-        router.StartRoutingTo(&handler);
-        content::RunMessageLoop();
-      }
+  bool found = false;
+  while (!found) {
+    found = ModelAssociatorHasTabWithUrl(index, url);

[Nicolas Zea, 2017/03/20 18:14:50]

nit: SyncableServiceHasTabWithURL (or perhaps SyncSessionsManagerHasTabWithURL
is clearer)

[Patrick Noland, 2017/03/21 22:54:31]

Done.

+    if (base::TimeTicks::Now() >= end_time) {
+      LOG(ERROR) << "Failed to find url " << url.spec() << " in tab after "
+                 << TestTimeouts::action_max_timeout().InSecondsF()
+                 << " seconds.";
+      return false;
+    }
+    if (!found) {
+      content::WaitForLoadStop(web_contents);
     }
   }
   return true;
 }
 
 bool GetLocalWindows(int index, ScopedWindowMap* local_windows) {
   // The local session provided by GetLocalSession is owned, and has lifetime
   // controlled, by the model associator, so we must make our own copy.

[Nicolas Zea, 2017/03/20 18:14:50]

nit: model associator -> SyncableService (may as well clean this up while we're
here, since there's not many references left)

[Patrick Noland, 2017/03/21 22:54:31]

Done.

   const sync_sessions::SyncedSession* local_session;
   if (!GetLocalSession(index, &local_session)) {
     return false;
   }
   for (auto w = local_session->windows.begin();
        w != local_session->windows.end(); ++w) {
     const sessions::SessionWindow& window = *(w->second);
     std::unique_ptr<sessions::SessionWindow> new_window =
         base::MakeUnique<sessions::SessionWindow>();
     new_window->window_id.set_id(window.window_id.id());
@@ skipping 198 matching lines @@
       index_(index),
       windows_(windows) {}
 
 bool ForeignSessionsMatchChecker::IsExitConditionSatisfied() {
   return sessions_helper::CheckForeignSessionsAgainst(index_, windows_);
 }
 
 std::string ForeignSessionsMatchChecker::GetDebugMessage() const {
   return "Waiting for matching foreign sessions";
 }