More scaffolding for back/forward, start of WebContents

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 "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 CommandLine;
 class MetricsService;
+class NavigationEntry;
 class ProfileManager;
 class Profile;
 class SessionID;
+class TabContents;
 class URLRequestContext;
 class WebContents;
 
 //---------------------------------------------------------------------------
 // These stubs are for Browser_main()
 
 class Upgrade {
  public:
   static bool IsBrowserAlreadyRunning() { return false; }
   static bool RelaunchChromeBrowser(const CommandLine& command_line) {
@@ skipping 182 matching lines @@
 void RegisterAllPrefs(PrefService*, PrefService*);
 }
 
 void OpenFirstRunDialog(Profile* profile);
 
 void InstallJankometer(const CommandLine&);
 
 //---------------------------------------------------------------------------
 // These stubs are for Browser
 
+class SavePackage {
+ public:
+  static bool IsSavableContents(const std::string& contents_mime_type) {
+    return false;
+  }
+  static bool IsSavableURL(const GURL& url) { return false; }
+};
+
 class LocationBarView {
  public:
   void ShowFirstRunBubble() { }
 };
 
+class GoButton {
+ public:
+  typedef enum Mode { MODE_GO = 0, MODE_STOP };
+  void ChangeMode(Mode mode) { }
+};
+
+class ToolbarStarToggle {
+ public:
+  void SetToggled(bool) { }
+};
+
 class DebuggerWindow : public base::RefCountedThreadSafe<DebuggerWindow> {
  public:
 };
 
 class TabStripModelDelegate {
  public:
 };
 
 class TabStripModelObserver {
  public:
 };
 
+class NavigationEntry {
+ public:
+  const GURL& url() const { return url_; }
+ private:
+  GURL url_;
+};
+
 class NavigationController {
  public:
+  NavigationController() : entry_(new NavigationEntry) { }
+  virtual ~NavigationController() { }
+  bool CanGoBack() const { return false; }
+  bool CanGoForward() const { return false; }
+  void GoBack() { }
+  void GoForward() { }
+  void Reload(bool) { }
+  TabContents* active_contents() const { return NULL; }
+  NavigationEntry* GetLastCommittedEntry() const { return entry_.get(); }
+  NavigationEntry* GetActiveEntry() const { return entry_.get(); }
+  void LoadURL(const GURL& url, const GURL& referrer,
+               PageTransition::Type type) { }
+ private:
+  scoped_ptr<NavigationEntry> entry_;
 };
 
 class TabContentsDelegate {
  public:
+   virtual void OpenURL(const GURL& url, const GURL& referrer,
+                        WindowOpenDisposition disposition,
+                        PageTransition::Type transition) { }
+};
+
+class InterstitialPage {
+ public:
+  virtual void DontProceed() { }
 };
 
 class TabContents {
  public:
   TabContents() : controller_(new NavigationController) { }
+  virtual ~TabContents() { }
   NavigationController* controller() const { return controller_.get(); }
-  WebContents* AsWebContents() const { return NULL; }
+  virtual WebContents* AsWebContents() const { return NULL; }
+  virtual SkBitmap GetFavIcon() const { return SkBitmap(); }
+  const GURL& GetURL() const { return url_; }
+  virtual const std::wstring& GetTitle() const { return title_; }
+  TabContentsType type() const { return TAB_CONTENTS_WEB; }
+  virtual void Focus() { }
  private:
+  GURL url_;
+  std::wstring title_;
   scoped_ptr<NavigationController> controller_;
 };
 
-// fake a tab strip, though it can't have any entries because the browser dtor
-// checks.
+class WebContents : public TabContents {
+ public:
+  WebContents* AsWebContents() { return this; }
+  bool showing_interstitial_page() const { return false; }
+  InterstitialPage* interstitial_page() const { return NULL; }
+  bool is_starred() const { return false; }
+  const std::string& contents_mime_type() const { return mime_type_; }
+ private:
+  std::string mime_type_;
+};
+
+// fake a tab strip with one entry.
 class TabStripModel {
  public:
   TabStripModel(TabStripModelDelegate* delegate, Profile* profile)
-      : contents_(new TabContents) { }
+      : contents_(new WebContents) { }
   virtual ~TabStripModel() { }
   bool empty() const { return contents_.get() == NULL; }
   int count() const { return contents_.get() ? 1 : 0; }
   int selected_index() const { return 0; }
   int GetIndexOfController(const NavigationController* controller) const {
     return 0;
   }
   TabContents* GetTabContentsAt(int index) const { return contents_.get(); }
   TabContents* GetSelectedTabContents() const { return contents_.get(); }
   void SelectTabContentsAt(int index, bool user_gesture) { }
@@ skipping 19 matching lines @@
 
 class DockInfo {
  public:
 };
 
 class ToolbarModel {
  public:
 };
 
 #endif  // CHROME_COMMON_TEMP_SCAFFOLDING_STUBS_H_