[sessions] Remove most knowledge of //chrome from core tab restore code

chrome/browser/sessions/tab_restore_service_helper.cc

 // Copyright 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/sessions/tab_restore_service_helper.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/tab_restore_service_delegate.h"
 #include "chrome/browser/sessions/tab_restore_service_observer.h"
-#include "chrome/common/url_constants.h"
 #include "components/sessions/content/content_serialized_navigation_builder.h"
+#include "components/sessions/core/tab_restore_service_client.h"
 #include "components/sessions/session_types.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/session_storage_namespace.h"
 #include "content/public/browser/web_contents.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/tab_helper.h"
-#include "chrome/common/extensions/extension_constants.h"
-#include "chrome/common/extensions/extension_metrics.h"
-#include "extensions/browser/extension_registry.h"
-#include "extensions/common/extension.h"
-#include "extensions/common/extension_set.h"
 #endif
 
 using content::NavigationController;
 using content::NavigationEntry;
 using content::WebContents;
 
-namespace {
-
-void RecordAppLaunch(Profile* profile, const TabRestoreService::Tab& tab) {
-#if defined(ENABLE_EXTENSIONS)
-  GURL url = tab.navigations.at(tab.current_navigation_index).virtual_url();
-  const extensions::Extension* extension =
-      extensions::ExtensionRegistry::Get(profile)
-          ->enabled_extensions().GetAppByURL(url);
-  if (!extension)
-    return;
-
-  extensions::RecordAppLaunchType(
-      extension_misc::APP_LAUNCH_NTP_RECENTLY_CLOSED,
-      extension->GetType());
-#endif  // defined(ENABLE_EXTENSIONS)
-}
-
-}  // namespace
-
 // TabRestoreServiceHelper::Observer -------------------------------------------
 
 TabRestoreServiceHelper::Observer::~Observer() {}
 
 void TabRestoreServiceHelper::Observer::OnClearEntries() {}
 
 void TabRestoreServiceHelper::Observer::OnRestoreEntryById(
     SessionID::id_type id,
     Entries::const_iterator entry_iterator) {
 }
 
 void TabRestoreServiceHelper::Observer::OnAddEntry() {}
 
 // TabRestoreServiceHelper -----------------------------------------------------
 
 TabRestoreServiceHelper::TabRestoreServiceHelper(
     TabRestoreService* tab_restore_service,
     Observer* observer,
     Profile* profile,
+    sessions::TabRestoreServiceClient* client,
     TabRestoreService::TimeFactory* time_factory)
     : tab_restore_service_(tab_restore_service),
       observer_(observer),
       profile_(profile),
+      client_(client),
       restoring_(false),
       time_factory_(time_factory) {
   DCHECK(tab_restore_service_);
 }
 
 TabRestoreServiceHelper::~TabRestoreServiceHelper() {
   FOR_EACH_OBSERVER(TabRestoreServiceObserver, observer_list_,
                     TabRestoreServiceDestroyed(tab_restore_service_));
   STLDeleteElements(&entries_);
 }
@@ skipping 161 matching lines @@
             delegate->GetTabCount(),
             tab.current_navigation_index,
             tab.extension_app_id,
             static_cast<int>(tab_i) == window->selected_tab_index,
             tab.pinned,
             tab.from_last_session,
             tab.session_storage_namespace.get(),
             tab.user_agent_override);
         if (restored_tab) {
           restored_tab->GetController().LoadIfNecessary();
-          RecordAppLaunch(profile_, tab);
+          client_->OnTabRestored(
+              tab.navigations.at(tab.current_navigation_index).virtual_url());
           web_contents.push_back(restored_tab);
         }
       }
       // All the window's tabs had the same former browser_id.
       if (window->tabs[0].has_browser()) {
         UpdateTabBrowserIDs(window->tabs[0].browser_id,
                             delegate->GetSessionID().id());
       }
     } else {
       // Restore a single tab from the window. Find the tab that matches the ID
@@ skipping 225 matching lines @@
                                             tab_index,
                                             tab.current_navigation_index,
                                             tab.extension_app_id,
                                             disposition != NEW_BACKGROUND_TAB,
                                             tab.pinned,
                                             tab.from_last_session,
                                             tab.session_storage_namespace.get(),
                                             tab.user_agent_override);
     web_contents->GetController().LoadIfNecessary();
   }
-  RecordAppLaunch(profile_, tab);
+  client_->OnTabRestored(
+      tab.navigations.at(tab.current_navigation_index).virtual_url());
   if (contents)
     *contents = web_contents;
 
   return delegate;
 }
 
 
 bool TabRestoreServiceHelper::ValidateTab(Tab* tab) {
   if (tab->navigations.empty())
     return false;
@@ skipping 32 matching lines @@
 }
 
 bool TabRestoreServiceHelper::IsTabInteresting(const Tab* tab) {
   if (tab->navigations.empty())
     return false;
 
   if (tab->navigations.size() > 1)
     return true;
 
   return tab->pinned ||
-      tab->navigations.at(0).virtual_url() !=
-          GURL(chrome::kChromeUINewTabURL);
+         tab->navigations.at(0).virtual_url() != client_->GetNewTabURL();
 }
 
 bool TabRestoreServiceHelper::IsWindowInteresting(const Window* window) {
   if (window->tabs.empty())
     return false;
 
   if (window->tabs.size() > 1)
     return true;
 
   return IsTabInteresting(&window->tabs[0]);
@@ skipping 20 matching lines @@
       Tab* tab = static_cast<Tab*>(entry);
       if (tab->browser_id == old_id)
         tab->browser_id = new_id;
     }
   }
 }
 
 base::Time TabRestoreServiceHelper::TimeNow() const {
   return time_factory_ ? time_factory_->TimeNow() : base::Time::Now();
 }