More scaffolding for back/forward, start of WebContents

chrome/browser/browser.cc

 // Copyright (c) 2006-2008 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 "base/command_line.h"
 #include "base/idle_timer.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/browser_list.h"
+#include "chrome/browser/metrics/user_metrics.h"
+#include "chrome/browser/tab_contents/tab_contents_type.h"
+#include "chrome/common/page_transition_types.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/cookie_policy.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domain.h"
 #include "net/url_request/url_request_context.h"
+#include "webkit/glue/window_open_disposition.h"
 
 #if defined(OS_WIN)
 
 #include <windows.h>
 #include <shellapi.h>
 
 #include "chrome/browser/browser.h"
 
 #include "chrome/app/locales/locale_settings.h"
 #include "chrome/browser/automation/ui_controls.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/browser_url_handler.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/cert_store.h"
 #include "chrome/browser/character_encoding.h"
 #include "chrome/browser/debugger/debugger_window.h"
 #include "chrome/browser/dock_info.h"
 #include "chrome/browser/dom_ui/new_tab_ui.h"
 #include "chrome/browser/download/save_package.h"
 #include "chrome/browser/history_tab_ui.h"
-#include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/options_window.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/plugin_process_host.h"
 #include "chrome/browser/plugin_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/ssl/ssl_error_info.h"
 #include "chrome/browser/tab_contents/interstitial_page.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
@@ skipping 490 matching lines @@
       return;
     }
   }
 
   TabContents* contents = CreateTabContentsForURL(url, GURL(), profile_,
                                                   PageTransition::LINK, false,
                                                   NULL);
   AddNewContents(NULL, contents, NEW_FOREGROUND_TAB, gfx::Rect(), true);
 }
 
+#endif  // OS_WIN
+
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Assorted browser commands:
 
 void Browser::GoBack() {
   UserMetrics::RecordAction(L"Back", profile_);
 
   // If we are showing an interstitial, just hide it.
   TabContents* current_tab = GetSelectedTabContents();
   WebContents* web_contents = current_tab->AsWebContents();
   if (web_contents && web_contents->interstitial_page()) {
     // The GoBack() case is a special case when an interstitial is shown because
     // the "previous" page is still available, just hidden by the interstitial.
     // We treat the back as a "Don't proceed", this hides the interstitial and
     // reveals the previous page.
     web_contents->interstitial_page()->DontProceed();
     return;
   }
   if (current_tab->controller()->CanGoBack())
     current_tab->controller()->GoBack();
 }
 
 void Browser::GoForward() {
   UserMetrics::RecordAction(L"Forward", profile_);
   if (GetSelectedTabContents()->controller()->CanGoForward())
     GetSelectedTabContents()->controller()->GoForward();
 }
 
+
 void Browser::Reload() {
   UserMetrics::RecordAction(L"Reload", profile_);
 
   // If we are showing an interstitial, treat this as an OpenURL.
   TabContents* current_tab = GetSelectedTabContents();
   if (current_tab) {
     WebContents* web_contents = current_tab->AsWebContents();
     if (web_contents && web_contents->showing_interstitial_page()) {
       NavigationEntry* entry = current_tab->controller()->GetActiveEntry();
       DCHECK(entry);  // Should exist if interstitial is showing.
       OpenURL(entry->url(), GURL(), CURRENT_TAB, PageTransition::RELOAD);
       return;
     }
   }
 
   if (current_tab) {
     // As this is caused by a user action, give the focus to the page.
     current_tab->Focus();
     current_tab->controller()->Reload(true);
   }
 }
 
+
 void Browser::Home() {
   UserMetrics::RecordAction(L"Home", profile_);
   GURL homepage_url = GetHomePage();
   GetSelectedTabContents()->controller()->LoadURL(
       homepage_url, GURL(), PageTransition::AUTO_BOOKMARK);
 }
 
+#if defined(OS_WIN)
 void Browser::OpenCurrentURL() {
   UserMetrics::RecordAction(L"LoadURL", profile_);
   LocationBarView* lbv = GetLocationBarView();
   if (lbv) {
     OpenURL(GURL(lbv->location_input()), GURL(), lbv->disposition(),
             lbv->transition());
   }
 }
 
 void Browser::Go() {
@@ skipping 468 matching lines @@
   // crashes, e.g. from Windows sending WM_COMMANDs at random times during
   // window construction.  This probably could use closer examination someday.
   if (!GetSelectedTabContents())
     return;
 
   DCHECK(command_updater_.IsCommandEnabled(id)) << "Invalid/disabled command";
 
   // The order of commands in this switch statement must match the function
   // declaration order in browser.h!
   switch (id) {
-#if defined(OS_WIN)
     // Navigation commands
     case IDC_BACK:                  GoBack();                      break;
     case IDC_FORWARD:               GoForward();                   break;
+#if defined(OS_WIN)
     case IDC_RELOAD:                Reload();                      break;
     case IDC_HOME:                  Home();                        break;
     case IDC_OPEN_CURRENT_URL:      OpenCurrentURL();              break;
     case IDC_GO:                    Go();                          break;
     case IDC_STOP:                  Stop();                        break;
 
      // Window management commands
     case IDC_NEW_WINDOW:            NewWindow();                   break;
     case IDC_NEW_INCOGNITO_WINDOW:  NewIncognitoWindow();          break;
     case IDC_NEW_WINDOW_PROFILE_0:
@@ skipping 185 matching lines @@
 
   if (!defer_load) {
     // Load the initial URL before adding the new tab contents to the tab strip
     // so that the tab contents has navigation state.
     contents->controller()->LoadURL(url, referrer, transition);
   }
 
   return contents;
 }
 
+#endif  // OS_WIN
+
 bool Browser::CanDuplicateContentsAt(int index) {
   TabContents* contents = GetTabContentsAt(index);
   DCHECK(contents);
 
   NavigationController* nc = contents->controller();
   return nc ? (nc->active_contents() && nc->GetLastCommittedEntry()) : false;
 }
 
+#if defined(OS_WIN)
+
 void Browser::DuplicateContentsAt(int index) {
   TabContents* contents = GetTabContentsAt(index);
   TabContents* new_contents = NULL;
   DCHECK(contents);
 
   if (type_ == TYPE_NORMAL) {
     // If this is a tabbed browser, just create a duplicate tab inside the same
     // window next to the tab being duplicated.
     new_contents = contents->controller()->Clone()->active_contents();
     // If you duplicate a tab that is not selected, we need to make sure to
@@ skipping 706 matching lines @@
                                           normal_window);
     command_updater_.UpdateCommandEnabled(IDC_IMPORT_SETTINGS, normal_window);
     command_updater_.UpdateCommandEnabled(IDC_OPTIONS, normal_window);
     command_updater_.UpdateCommandEnabled(IDC_EDIT_SEARCH_ENGINES,
                                           normal_window);
     command_updater_.UpdateCommandEnabled(IDC_VIEW_PASSWORDS, normal_window);
     command_updater_.UpdateCommandEnabled(IDC_ABOUT, normal_window);
   }
 }
 
-#if defined(OS_WIN)
-
 void Browser::UpdateCommandsForTabState() {
   TabContents* current_tab = GetSelectedTabContents();
   if (!current_tab)  // May be NULL during tab restore.
     return;
 
   // Navigation commands
   NavigationController* nc = current_tab->controller();
   command_updater_.UpdateCommandEnabled(IDC_BACK, nc->CanGoBack());
   command_updater_.UpdateCommandEnabled(IDC_FORWARD, nc->CanGoForward());
 
@@ skipping 48 matching lines @@
   command_updater_.UpdateCommandEnabled(IDC_GO, !is_loading);
   command_updater_.UpdateCommandEnabled(IDC_STOP, is_loading);
 }
 
 void Browser::SetStarredButtonToggled(bool starred) {
   ToolbarStarToggle* star_button = window_->GetStarButton();
   if (star_button)
     star_button->SetToggled(starred);
 }
 
+#if defined(OS_WIN)
+
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, UI update coalescing and handling (private):
 
 void Browser::UpdateToolbar(bool should_restore_state) {
   window_->UpdateToolbar(GetSelectedTabContents(), should_restore_state);
 }
 
 void Browser::ScheduleUIUpdate(const TabContents* source,
                                unsigned changed_flags) {
   // Synchronously update the URL.
@@ skipping 108 matching lines @@
   UpdateVector::iterator cur_update = scheduled_updates_.begin();
   while (cur_update != scheduled_updates_.end()) {
     if (cur_update->source == contents) {
       cur_update = scheduled_updates_.erase(cur_update);
     } else {
       ++cur_update;
     }
   }
 }
 
+#endif  // OS_WIN
+
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Getters for UI (private):
 
 LocationBarView* Browser::GetLocationBarView() const {
   return window_->GetLocationBarView();
 }
 
 GoButton* Browser::GetGoButton() {
   return window_->GetGoButton();
 }
 
 StatusBubble* Browser::GetStatusBubble() {
   return window_->GetStatusBubble();
 }
 
+#if defined(OS_WIN)
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Session restore functions (private):
 
 void Browser::SyncHistoryWithTabs(int index) {
   if (!profile()->HasSessionService())
     return;
   SessionService* session_service = profile()->GetSessionService();
   if (session_service) {
     for (int i = index; i < tab_count(); ++i) {
       TabContents* contents = GetTabContentsAt(i);
@@ skipping 167 matching lines @@
   std::wstring window_pref(prefs::kBrowserWindowPlacement);
   window_pref.append(L"_");
   window_pref.append(app_name);
   PrefService* prefs = g_browser_process->local_state();
   DCHECK(prefs);
 
   prefs->RegisterDictionaryPref(window_pref.c_str());
 }
 
 #endif  // OS_WIN