[sessions] Properly namespace recently-componentized TabRestore code

chrome/browser/ui/cocoa/history_menu_bridge.h

 // Copyright (c) 2011 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.
 
 #ifndef CHROME_BROWSER_UI_COCOA_HISTORY_MENU_BRIDGE_H_
 #define CHROME_BROWSER_UI_COCOA_HISTORY_MENU_BRIDGE_H_
 
 #import <Cocoa/Cocoa.h>
 #include <map>
 #include <vector>
 
 #include "base/mac/scoped_nsobject.h"
 #include "base/memory/ref_counted.h"
 #include "base/scoped_observer.h"
 #include "base/task/cancelable_task_tracker.h"
 #import "chrome/browser/ui/cocoa/main_menu_item.h"
 #import "components/favicon/core/favicon_service.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/browser/history_service_observer.h"
 #include "components/sessions/core/tab_restore_service.h"
 #include "components/sessions/core/tab_restore_service_observer.h"
 #include "components/sessions/session_id.h"
 
 class Profile;
-class TabRestoreService;
 @class HistoryMenuCocoaController;
 
 namespace {
 class HistoryMenuBridgeTest;
 }
 
 namespace favicon_base {
 struct FaviconImageResult;
 }
 
@@ skipping 12 matching lines @@
 // have a tag that's equal to the parent + 1. Tags within the history menu have
 // a range of [400,500) and do not go through CommandDispatch for their target-
 // action mechanism.
 //
 // These menu items do not use firstResponder as their target. Rather, they are
 // hooked directly up to the HistoryMenuCocoaController that then bridges back
 // to this class. These items are created via the AddItemToMenu() helper. Also,
 // unlike the typical ownership model, this bridge owns its controller. The
 // controller is very thin and only exists to interact with Cocoa, but this
 // class does the bulk of the work.
-class HistoryMenuBridge : public TabRestoreServiceObserver,
+class HistoryMenuBridge : public sessions::TabRestoreServiceObserver,
                           public MainMenuItem,
                           public history::HistoryServiceObserver {
  public:
   // This is a generalization of the data we store in the history menu because
   // we pull things from different sources with different data types.
   struct HistoryItem {
    public:
     HistoryItem();
     // Copy constructor allowed.
     HistoryItem(const HistoryItem& copy);
@@ skipping 50 matching lines @@
     kVisitedSeparator = 440,  // Separator before visited section.
     kVisitedTitle = 441,  // Title of the visited section.
     kVisited = 460,  // Used for all entries in the visited section.
     kShowFullSeparator = 480  // Separator after the visited section.
   };
 
   explicit HistoryMenuBridge(Profile* profile);
   ~HistoryMenuBridge() override;
 
   // TabRestoreServiceObserver:
-  void TabRestoreServiceChanged(TabRestoreService* service) override;
-  void TabRestoreServiceDestroyed(TabRestoreService* service) override;
+  void TabRestoreServiceChanged(sessions::TabRestoreService* service) override;
+  void TabRestoreServiceDestroyed(
+      sessions::TabRestoreService* service) override;
 
   // MainMenuItem:
   void ResetMenu() override;
   void BuildMenu() override;
 
   // Looks up an NSMenuItem in the |menu_item_map_| and returns the
   // corresponding HistoryItem.
   HistoryItem* HistoryItemForMenuItem(NSMenuItem* item);
 
   // I wish I has a "friend @class" construct. These are used by the HMCC
@@ skipping 31 matching lines @@
 
   // Invoked when the History information has changed.
   void OnHistoryChanged();
 
   // Callback method for when HistoryService query results are ready with the
   // most recently-visited sites.
   void OnVisitedHistoryResults(history::QueryResults* results);
 
   // Creates a HistoryItem* for the given tab entry. Caller takes ownership of
   // the result and must delete it when finished.
-  HistoryItem* HistoryItemForTab(const TabRestoreService::Tab& entry);
+  HistoryItem* HistoryItemForTab(const sessions::TabRestoreService::Tab& entry);
 
   // Helper function that sends an async request to the FaviconService to get
   // an icon. The callback will update the NSMenuItem directly.
   void GetFaviconForHistoryItem(HistoryItem* item);
 
   // Callback for the FaviconService to return favicon image data when we
   // request it. This decodes the raw data, updates the HistoryItem, and then
   // sets the image on the menu. Called on the same same thread that
   // GetFaviconForHistoryItem() was called on (UI thread).
   void GotFaviconData(HistoryItem* item,
@@ skipping 19 matching lines @@
                      bool all_history,
                      bool expired,
                      const history::URLRows& deleted_rows,
                      const std::set<GURL>& favicon_urls) override;
   void OnHistoryServiceLoaded(history::HistoryService* service) override;
 
   base::scoped_nsobject<HistoryMenuCocoaController> controller_;  // strong
 
   Profile* profile_;  // weak
   history::HistoryService* history_service_;  // weak
-  TabRestoreService* tab_restore_service_;  // weak
+  sessions::TabRestoreService* tab_restore_service_;  // weak
 
   base::CancelableTaskTracker cancelable_task_tracker_;
 
   // Mapping of NSMenuItems to HistoryItems. This owns the HistoryItems until
   // they are removed and deleted via ClearMenuSection().
   std::map<NSMenuItem*, HistoryItem*> menu_item_map_;
 
   // Requests to re-create the menu are coalesced. |create_in_progress_| is true
   // when either waiting for the history service to return query results, or
   // when the menu is rebuilding. |need_recreate_| is true whenever a rebuild
   // has been scheduled but is waiting for the current one to finish.
   bool create_in_progress_;
   bool need_recreate_;
 
   // The default favicon if a HistoryItem does not have one.
   base::scoped_nsobject<NSImage> default_favicon_;
 
   ScopedObserver<history::HistoryService, history::HistoryServiceObserver>
       history_service_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryMenuBridge);
 };
 
 #endif  // CHROME_BROWSER_UI_COCOA_HISTORY_MENU_BRIDGE_H_