Roll forward 8722,8721

chrome/common/temp_scaffolding_stubs.h

 // Copyright (c) 2009 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_COMMON_TEMP_SCAFFOLDING_STUBS_H_
 #define CHROME_COMMON_TEMP_SCAFFOLDING_STUBS_H_
 
 // This file provides declarations and stub definitions for classes we encouter
 // during the porting effort. It is not meant to be perminent, and classes will
 // be removed from here as they are fleshed out more completely.
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/ref_counted.h"
 #include "base/gfx/rect.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/tab_contents/tab_contents_type.h"
 #include "chrome/common/page_transition_types.h"
 #include "googleurl/src/gurl.h"
 #include "skia/include/SkBitmap.h"
 #include "webkit/glue/window_open_disposition.h"
 
 class Browser;
+class BookmarkService;
 class CommandLine;
+class HistoryService;
 class MetricsService;
 class NavigationEntry;
 class ProfileManager;
 class Profile;
 class SessionID;
+class SpellChecker;
 class TabContents;
 class URLRequestContext;
+class UserScriptMaster;
+class VisitedLinkMaster;
 class WebContents;
 
 //---------------------------------------------------------------------------
 // These stubs are for Browser_main()
 
 class Upgrade {
  public:
   static bool IsBrowserAlreadyRunning() { return false; }
   static bool RelaunchChromeBrowser(const CommandLine& command_line) {
     return true;
@@ skipping 125 matching lines @@
   void WindowClosed(const SessionID &) { }
   void SetWindowBounds(const SessionID&, const gfx::Rect&, bool) { }
 };
 
 class TabRestoreService {
  public:
   void BrowserClosing(Browser*) { }
   void BrowserClosed(Browser*) { }
 };
 
+class HistoryService {
+ public:
+
+  class URLEnumerator {
+   public:
+    virtual ~URLEnumerator() {}
+    virtual void OnURL(const GURL& url) = 0;
+    virtual void OnComplete(bool success) = 0;
+  };
+
+  HistoryService() {}
+  bool Init(const std::wstring& history_dir, BookmarkService* bookmark_service)
+      { return false; }
+  void SetOnBackendDestroyTask(Task*) {}
+  void AddPage(GURL const&, void const*, int, GURL const&,
+               int, std::vector<GURL> const&) {}
+  void AddPage(const GURL& url) {}
+  void SetPageContents(const GURL& url, const std::wstring& contents) {}
+  void IterateURLs(URLEnumerator* iterator) {}
+  void Cleanup() {}
+  void AddRef() {}
+  void Release() {}
+};
+
 class Profile {
  public:
+   enum ServiceAccessType {
+    EXPLICIT_ACCESS,
+    IMPLICIT_ACCESS
+  };
+
+ public:
   Profile(const std::wstring& user_data_dir);
   virtual std::wstring GetPath() { return path_; }
   virtual PrefService* GetPrefs();
   void ResetTabRestoreService() { }
+  SpellChecker* GetSpellChecker() { return NULL; }
+  VisitedLinkMaster* GetVisitedLinkMaster() { return NULL; }
   TabRestoreService* GetTabRestoreService() { return NULL; }
   SessionService* GetSessionService() { return NULL; }
+  UserScriptMaster* GetUserScriptMaster() { return NULL; }
   bool IsOffTheRecord() { return false; }
   URLRequestContext* GetRequestContext() { return NULL; }
   virtual Profile* GetOriginalProfile() { return this; }
   virtual Profile* GetOffTheRecordProfile() { return this; }
   bool HasSessionService() { return false; }
+  std::wstring GetID() { return L""; }
+  HistoryService* GetHistoryService(ServiceAccessType access) {
+    return &history_service_;
+  }
+
  private:
   std::wstring GetPrefFilePath();
 
   std::wstring path_;
   scoped_ptr<PrefService> prefs_;
+  HistoryService history_service_;
 };
 
 class ProfileManager : NonThreadSafe {
  public:
   ProfileManager() { }
   virtual ~ProfileManager() { }
   Profile* GetDefaultProfile(const std::wstring& user_data_dir);
   static std::wstring GetDefaultProfileDir(const std::wstring& user_data_dir);
   static std::wstring GetDefaultProfilePath(const std::wstring& profile_dir);
   static void ShutdownSessionServices() { }
@@ skipping 178 matching lines @@
 
 class WindowSizer {
  public:
   static void GetBrowserWindowBounds(const std::wstring& app_name,
                                      const gfx::Rect& specified_bounds,
                                      gfx::Rect* window_bounds,
                                      bool* maximized) { }
 };
 
 #endif  // CHROME_COMMON_TEMP_SCAFFOLDING_STUBS_H_