blob: fd97827e0c4fe799218464bb21371c557929f842 [file] [log] [blame]
[email protected]ce5c4502009-05-06 16:46:111// Copyright (c) 2009 The Chromium Authors. All rights reserved.
license.botbf09a502008-08-24 00:55:552// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commit09911bf2008-07-26 23:55:294
[email protected]f3ec7742009-01-15 00:59:165#include "chrome/browser/tab_contents/tab_contents.h"
initial.commit09911bf2008-07-26 23:55:296
[email protected]beb440c2009-11-06 04:08:547#include "app/gfx/text_elider.h"
[email protected]a92b8642009-05-05 23:38:568#include "app/l10n_util.h"
[email protected]9929da92009-05-05 02:05:119#include "app/resource_bundle.h"
[email protected]420ae012009-04-24 05:16:3210#include "base/file_version_info.h"
11#include "base/process_util.h"
[email protected]96d185d2009-04-24 03:28:5412#include "base/string16.h"
[email protected]996fd702009-09-04 19:12:3713#include "base/string_util.h"
[email protected]96d185d2009-04-24 03:28:5414#include "base/time.h"
[email protected]21674df2009-10-28 19:51:2115#include "chrome/browser/autofill/autofill_manager.h"
[email protected]66ba4932009-06-04 19:22:1316#include "chrome/browser/blocked_popup_container.h"
[email protected]420ae012009-04-24 05:16:3217#include "chrome/browser/bookmarks/bookmark_model.h"
[email protected]96d185d2009-04-24 03:28:5418#include "chrome/browser/browser_process.h"
initial.commit09911bf2008-07-26 23:55:2919#include "chrome/browser/cert_store.h"
[email protected]aacd7cc2009-09-02 14:51:1020#include "chrome/browser/character_encoding.h"
[email protected]96d185d2009-04-24 03:28:5421#include "chrome/browser/debugger/devtools_manager.h"
[email protected]420ae012009-04-24 05:16:3222#include "chrome/browser/dom_operation_notification_details.h"
[email protected]96d185d2009-04-24 03:28:5423#include "chrome/browser/dom_ui/dom_ui.h"
24#include "chrome/browser/dom_ui/dom_ui_factory.h"
[email protected]bcef0dc02009-02-28 00:35:0225#include "chrome/browser/download/download_item_model.h"
[email protected]420ae012009-04-24 05:16:3226#include "chrome/browser/download/download_manager.h"
27#include "chrome/browser/download/download_request_manager.h"
[email protected]e7eaedde2009-09-25 20:09:4928#include "chrome/browser/external_protocol_handler.h"
[email protected]92c6f9b92009-10-24 04:35:0829#include "chrome/browser/extensions/extensions_service.h"
[email protected]0189bc722009-08-28 21:56:4830#include "chrome/browser/favicon_service.h"
[email protected]19289d02009-10-21 21:47:0031#include "chrome/browser/form_field_history_manager.h"
[email protected]420ae012009-04-24 05:16:3232#include "chrome/browser/google_util.h"
[email protected]8897c382009-05-06 17:53:2633#include "chrome/browser/hung_renderer_dialog.h"
[email protected]420ae012009-04-24 05:16:3234#include "chrome/browser/jsmessage_box_handler.h"
35#include "chrome/browser/load_from_memory_cache_details.h"
36#include "chrome/browser/load_notification_details.h"
[email protected]84abba62009-10-07 17:01:4437#include "chrome/browser/metrics/metric_event_duration_details.h"
[email protected]ea0e80892009-08-22 00:36:0538#include "chrome/browser/modal_html_dialog_delegate.h"
[email protected]c8865482009-07-23 20:40:1039#include "chrome/browser/omnibox_search_hint.h"
[email protected]fdd61c62009-04-22 19:22:5740#include "chrome/browser/password_manager/password_manager.h"
41#include "chrome/browser/plugin_installer.h"
[email protected]ce560f82009-06-03 09:39:4442#include "chrome/browser/profile.h"
[email protected]1db6ff152009-10-12 15:32:0743#include "chrome/browser/renderer_host/render_process_host.h"
[email protected]96d185d2009-04-24 03:28:5444#include "chrome/browser/renderer_host/render_widget_host_view.h"
[email protected]fd694982009-07-03 17:32:3745#include "chrome/browser/renderer_host/resource_request_details.h"
[email protected]1db6ff152009-10-12 15:32:0746#include "chrome/browser/renderer_host/site_instance.h"
[email protected]96d185d2009-04-24 03:28:5447#include "chrome/browser/renderer_host/web_cache_manager.h"
[email protected]93623c5d2009-12-10 21:40:3248#include "chrome/browser/renderer_preferences_util.h"
[email protected]bd1ad682009-05-15 22:19:1749#include "chrome/browser/tab_contents/infobar_delegate.h"
[email protected]7e383692009-06-12 19:14:5450#include "chrome/browser/tab_contents/interstitial_page.h"
[email protected]f3ec7742009-01-15 00:59:1651#include "chrome/browser/tab_contents/navigation_entry.h"
[email protected]de34a962009-06-26 23:22:4352#include "chrome/browser/tab_contents/provisional_load_details.h"
[email protected]f3ec7742009-01-15 00:59:1653#include "chrome/browser/tab_contents/tab_contents_delegate.h"
[email protected]fdd61c62009-04-22 19:22:5754#include "chrome/browser/tab_contents/tab_contents_view.h"
[email protected]58dca552009-06-17 00:35:0255#include "chrome/browser/tab_contents/thumbnail_generator.h"
[email protected]449478302009-06-09 20:04:2856#include "chrome/browser/thumbnail_store.h"
[email protected]420ae012009-04-24 05:16:3257#include "chrome/browser/search_engines/template_url_fetcher.h"
58#include "chrome/browser/search_engines/template_url_model.h"
[email protected]35f7d212009-04-29 21:19:2759#include "chrome/common/chrome_switches.h"
[email protected]5d246db22009-10-27 06:17:5760#include "chrome/common/extensions/extension_action.h"
[email protected]bfd04a62009-02-01 18:16:5661#include "chrome/common/notification_service.h"
[email protected]89d6e6e2009-12-03 23:06:5162#include "chrome/common/platform_util.h"
initial.commit09911bf2008-07-26 23:55:2963#include "chrome/common/pref_names.h"
[email protected]1eb89e82008-08-15 12:27:0364#include "chrome/common/pref_service.h"
[email protected]420ae012009-04-24 05:16:3265#include "chrome/common/render_messages.h"
[email protected]1ee614862009-07-06 20:29:1866#include "chrome/common/renderer_preferences.h"
[email protected]96d185d2009-04-24 03:28:5467#include "chrome/common/url_constants.h"
[email protected]8897c382009-05-06 17:53:2668#include "grit/generated_resources.h"
[email protected]420ae012009-04-24 05:16:3269#include "grit/locale_settings.h"
70#include "net/base/mime_util.h"
71#include "net/base/net_errors.h"
[email protected]d686e812009-06-03 19:10:2972#include "net/base/net_util.h"
[email protected]420ae012009-04-24 05:16:3273#include "net/base/registry_controlled_domain.h"
[email protected]1ee614862009-07-06 20:29:1874#include "webkit/glue/password_form.h"
75#include "webkit/glue/webpreferences.h"
[email protected]3e45ba92009-02-20 21:09:0076
[email protected]304f8792009-08-19 21:28:0977#if defined(OS_CHROMEOS)
78// For GdkScreen
79#include <gdk/gdk.h>
[email protected]0ba5c5e2009-08-20 16:47:1380#endif // defined(OS_CHROMEOS)
81
[email protected]420ae012009-04-24 05:16:3282// Cross-Site Navigations
83//
84// If a TabContents is told to navigate to a different web site (as determined
85// by SiteInstance), it will replace its current RenderViewHost with a new
86// RenderViewHost dedicated to the new SiteInstance. This works as follows:
87//
88// - Navigate determines whether the destination is cross-site, and if so,
89// it creates a pending_render_view_host_ and moves into the PENDING
90// RendererState.
91// - The pending RVH is "suspended," so that no navigation messages are sent to
92// its renderer until the onbeforeunload JavaScript handler has a chance to
93// run in the current RVH.
94// - The pending RVH tells CrossSiteRequestManager (a thread-safe singleton)
95// that it has a pending cross-site request. ResourceDispatcherHost will
96// check for this when the response arrives.
97// - The current RVH runs its onbeforeunload handler. If it returns false, we
98// cancel all the pending logic and go back to NORMAL. Otherwise we allow
99// the pending RVH to send the navigation request to its renderer.
100// - ResourceDispatcherHost receives a ResourceRequest on the IO thread. It
101// checks CrossSiteRequestManager to see that the RVH responsible has a
102// pending cross-site request, and then installs a CrossSiteEventHandler.
103// - When RDH receives a response, the BufferedEventHandler determines whether
104// it is a download. If so, it sends a message to the new renderer causing
105// it to cancel the request, and the download proceeds in the download
106// thread. For now, we stay in a PENDING state (with a pending RVH) until
[email protected]57c6a652009-05-04 07:58:34107// the next DidNavigate event for this TabContents. This isn't ideal, but it
[email protected]420ae012009-04-24 05:16:32108// doesn't affect any functionality.
109// - After RDH receives a response and determines that it is safe and not a
110// download, it pauses the response to first run the old page's onunload
111// handler. It does this by asynchronously calling the OnCrossSiteResponse
[email protected]57c6a652009-05-04 07:58:34112// method of TabContents on the UI thread, which sends a ClosePage message
[email protected]420ae012009-04-24 05:16:32113// to the current RVH.
114// - Once the onunload handler is finished, a ClosePage_ACK message is sent to
115// the ResourceDispatcherHost, who unpauses the response. Data is then sent
116// to the pending RVH.
117// - The pending renderer sends a FrameNavigate message that invokes the
118// DidNavigate method. This replaces the current RVH with the
119// pending RVH and goes back to the NORMAL RendererState.
120
121namespace {
122
123// Amount of time we wait between when a key event is received and the renderer
124// is queried for its state and pushed to the NavigationEntry.
125const int kQueryStateDelay = 5000;
126
127const int kSyncWaitDelay = 40;
128
[email protected]304f8792009-08-19 21:28:09129#if defined(OS_CHROMEOS)
130// If a popup window is bigger than this fraction of the screen on chrome os,
131// turn it into a tab
132const float kMaxWidthFactor = 0.5;
133const float kMaxHeightFactor = 0.6;
134#endif
135
[email protected]420ae012009-04-24 05:16:32136// If another javascript message box is displayed within
137// kJavascriptMessageExpectedDelay of a previous javascript message box being
138// dismissed, display an option to suppress future message boxes from this
139// contents.
140const int kJavascriptMessageExpectedDelay = 1000;
141
[email protected]420ae012009-04-24 05:16:32142// The list of prefs we want to observe.
143const wchar_t* kPrefsToObserve[] = {
144 prefs::kAlternateErrorPagesEnabled,
145 prefs::kWebKitJavaEnabled,
146 prefs::kWebKitJavascriptEnabled,
147 prefs::kWebKitLoadsImagesAutomatically,
148 prefs::kWebKitPluginsEnabled,
149 prefs::kWebKitUsesUniversalDetector,
150 prefs::kWebKitSerifFontFamily,
151 prefs::kWebKitSansSerifFontFamily,
152 prefs::kWebKitFixedFontFamily,
153 prefs::kWebKitDefaultFontSize,
154 prefs::kWebKitDefaultFixedFontSize,
155 prefs::kDefaultCharset
156 // kWebKitStandardFontIsSerif needs to be added
157 // if we let users pick which font to use, serif or sans-serif when
158 // no font is specified or a CSS generic family (serif or sans-serif)
159 // is not specified.
160};
161
162const int kPrefsToObserveLength = arraysize(kPrefsToObserve);
163
[email protected]420ae012009-04-24 05:16:32164// Returns true if the entry's transition type is FORM_SUBMIT.
165bool IsFormSubmit(const NavigationEntry* entry) {
166 return (PageTransition::StripQualifier(entry->transition_type()) ==
167 PageTransition::FORM_SUBMIT);
168}
169
170#if defined(OS_WIN)
171
172BOOL CALLBACK InvalidateWindow(HWND hwnd, LPARAM lparam) {
173 // Note: erase is required to properly paint some widgets borders. This can
174 // be seen with textfields.
175 InvalidateRect(hwnd, NULL, TRUE);
176 return TRUE;
177}
178#endif
179
[email protected]5e369672009-11-03 23:48:30180ViewMsg_Navigate_Params::NavigationType GetNavigationType(
181 Profile* profile, const NavigationEntry& entry, bool reload) {
182 if (reload)
183 return ViewMsg_Navigate_Params::RELOAD;
184
185 if (entry.restore_type() == NavigationEntry::RESTORE_LAST_SESSION &&
186 profile->DidLastSessionExitCleanly())
187 return ViewMsg_Navigate_Params::RESTORE;
188
189 return ViewMsg_Navigate_Params::NORMAL;
190}
191
192void MakeNavigateParams(Profile* profile, const NavigationEntry& entry,
193 bool reload, ViewMsg_Navigate_Params* params) {
[email protected]056de2d2009-06-26 16:41:34194 params->page_id = entry.page_id();
195 params->url = entry.url();
196 params->referrer = entry.referrer();
197 params->transition = entry.transition_type();
198 params->state = entry.content_state();
[email protected]5e369672009-11-03 23:48:30199 params->navigation_type = GetNavigationType(profile, entry, reload);
[email protected]056de2d2009-06-26 16:41:34200 params->request_time = base::Time::Now();
201}
202
[email protected]420ae012009-04-24 05:16:32203} // namespace
204
205// -----------------------------------------------------------------------------
206
[email protected]fdd61c62009-04-22 19:22:57207// static
208int TabContents::find_request_id_counter_ = -1;
209
[email protected]420ae012009-04-24 05:16:32210
[email protected]420ae012009-04-24 05:16:32211TabContents::TabContents(Profile* profile,
212 SiteInstance* site_instance,
213 int routing_id,
[email protected]34ac70502009-09-25 17:07:23214 const TabContents* base_tab_contents)
[email protected]b680ad22009-04-15 23:19:42215 : delegate_(NULL),
[email protected]66ba4932009-06-04 19:22:13216 ALLOW_THIS_IN_INITIALIZER_LIST(controller_(this, profile)),
217 ALLOW_THIS_IN_INITIALIZER_LIST(view_(
[email protected]d82ed61e2009-06-16 02:46:22218 TabContentsView::Create(this))),
219 ALLOW_THIS_IN_INITIALIZER_LIST(render_manager_(this, this)),
[email protected]fdd61c62009-04-22 19:22:57220 property_bag_(),
221 registrar_(),
[email protected]d82ed61e2009-06-16 02:46:22222 ALLOW_THIS_IN_INITIALIZER_LIST(printing_(*this)),
[email protected]fdd61c62009-04-22 19:22:57223 save_package_(),
[email protected]19289d02009-10-21 21:47:00224 form_field_history_manager_(),
[email protected]21674df2009-10-28 19:51:21225 autofill_manager_(),
[email protected]fdd61c62009-04-22 19:22:57226 password_manager_(),
227 plugin_installer_(),
[email protected]d82ed61e2009-06-16 02:46:22228 ALLOW_THIS_IN_INITIALIZER_LIST(fav_icon_helper_(this)),
[email protected]fdd61c62009-04-22 19:22:57229 select_file_dialog_(),
[email protected]d5f942ba2008-09-26 19:30:34230 is_loading_(false),
initial.commit09911bf2008-07-26 23:55:29231 is_crashed_(false),
[email protected]d5f942ba2008-09-26 19:30:34232 waiting_for_response_(false),
[email protected]d5f942ba2008-09-26 19:30:34233 max_page_id_(-1),
[email protected]fdd61c62009-04-22 19:22:57234 current_load_start_(),
235 load_state_(net::LOAD_STATE_IDLE),
236 load_state_host_(),
[email protected]094e5b22009-09-25 04:23:56237 upload_size_(0),
238 upload_position_(0),
[email protected]fdd61c62009-04-22 19:22:57239 received_page_title_(false),
240 is_starred_(false),
241 contents_mime_type_(),
242 encoding_(),
[email protected]332af7732009-03-11 13:21:35243 blocked_popups_(NULL),
[email protected]fdd61c62009-04-22 19:22:57244 infobar_delegates_(),
[email protected]fdd61c62009-04-22 19:22:57245 find_ui_active_(false),
246 find_op_aborted_(false),
247 current_find_request_id_(find_request_id_counter_++),
[email protected]e491f1c2009-05-22 20:28:12248 last_search_case_sensitive_(false),
249 last_search_prepopulate_text_(NULL),
250 last_search_result_(),
[email protected]fdd61c62009-04-22 19:22:57251 capturing_contents_(false),
252 is_being_destroyed_(false),
253 notify_disconnection_(false),
254 history_requests_(),
255#if defined(OS_WIN)
256 message_box_active_(CreateEvent(NULL, TRUE, FALSE, NULL)),
257#endif
258 last_javascript_message_dismissal_(),
[email protected]c2e74fe82009-09-03 17:57:44259 suppress_javascript_messages_(false),
[email protected]7ab1e7d62009-10-14 23:32:01260 is_showing_before_unload_dialog_(false),
[email protected]93623c5d2009-12-10 21:40:32261 renderer_preferences_(
262 renderer_preferences_util::GetInitedRendererPreferences(profile)),
[email protected]c2e74fe82009-09-03 17:57:44263 opener_dom_ui_type_(DOMUIFactory::kNoDOMUI) {
[email protected]16779842009-07-08 23:45:29264#if defined(OS_CHROMEOS)
[email protected]58dca552009-06-17 00:35:02265 // Make sure the thumbnailer is started before starting the render manager.
266 // The thumbnailer will want to listen for RVH creations, one of which will
267 // happen in RVHManager::Init.
268 ThumbnailGenerator* generator = g_browser_process->GetThumbnailGenerator();
269 if (generator)
270 generator->StartThumbnailing();
271#endif
272
[email protected]12636df2009-09-28 22:32:21273 render_manager_.Init(profile, site_instance, routing_id);
[email protected]420ae012009-04-24 05:16:32274
[email protected]34ac70502009-09-25 17:07:23275 // We have the initial size of the view be based on the size of the passed in
276 // tab contents (normally a tab from the same window).
277 view_->CreateView(base_tab_contents ?
278 base_tab_contents->view()->GetContainerSize() : gfx::Size());
[email protected]420ae012009-04-24 05:16:32279
280 // Register for notifications about all interested prefs change.
281 PrefService* prefs = profile->GetPrefs();
282 if (prefs) {
283 for (int i = 0; i < kPrefsToObserveLength; ++i)
284 prefs->AddPrefObserver(kPrefsToObserve[i], this);
285 }
286
287 // Register for notifications about URL starredness changing on any profile.
288 registrar_.Add(this, NotificationType::URLS_STARRED,
289 NotificationService::AllSources());
290 registrar_.Add(this, NotificationType::BOOKMARK_MODEL_LOADED,
291 NotificationService::AllSources());
292 registrar_.Add(this, NotificationType::RENDER_WIDGET_HOST_DESTROYED,
293 NotificationService::AllSources());
[email protected]d3ba77272009-09-03 00:06:09294#if defined(OS_LINUX)
295 registrar_.Add(this, NotificationType::BROWSER_THEME_CHANGED,
296 NotificationService::AllSources());
297#endif
[email protected]420ae012009-04-24 05:16:32298
299 // Keep a global copy of the previous search string (if any).
300 static string16 global_last_search = string16();
[email protected]e491f1c2009-05-22 20:28:12301 last_search_prepopulate_text_ = &global_last_search;
[email protected]840b1512009-07-21 16:53:46302
[email protected]c8865482009-07-23 20:40:10303 // Set-up the showing of the omnibox search infobar if applicable.
304 if (OmniboxSearchHint::IsEnabled(profile))
305 omnibox_search_hint_.reset(new OmniboxSearchHint(this));
[email protected]332af7732009-03-11 13:21:35306}
initial.commit09911bf2008-07-26 23:55:29307
308TabContents::~TabContents() {
[email protected]420ae012009-04-24 05:16:32309 is_being_destroyed_ = true;
310
[email protected]bfe4c1582009-10-02 18:11:09311 // We don't want any notifications while we're running our destructor.
[email protected]420ae012009-04-24 05:16:32312 registrar_.RemoveAll();
313
314 // Unregister the notifications of all observed prefs change.
315 PrefService* prefs = profile()->GetPrefs();
316 if (prefs) {
317 for (int i = 0; i < kPrefsToObserveLength; ++i)
318 prefs->RemovePrefObserver(kPrefsToObserve[i], this);
319 }
320
[email protected]420ae012009-04-24 05:16:32321 NotifyDisconnected();
[email protected]e7b8d832009-11-20 22:41:00322 hung_renderer_dialog::HideForTabContents(this);
[email protected]420ae012009-04-24 05:16:32323
[email protected]420ae012009-04-24 05:16:32324 // First cleanly close all child windows.
325 // TODO(mpcomplete): handle case if MaybeCloseChildWindows() already asked
326 // some of these to close. CloseWindows is async, so it might get called
327 // twice before it runs.
328 int size = static_cast<int>(child_windows_.size());
329 for (int i = size - 1; i >= 0; --i) {
330 ConstrainedWindow* window = child_windows_[i];
331 if (window)
332 window->CloseConstrainedWindow();
333 }
334
[email protected]66ba4932009-06-04 19:22:13335 if (blocked_popups_)
336 blocked_popups_->Destroy();
337
[email protected]420ae012009-04-24 05:16:32338 // Notify any observer that have a reference on this tab contents.
339 NotificationService::current()->Notify(
340 NotificationType::TAB_CONTENTS_DESTROYED,
341 Source<TabContents>(this),
342 NotificationService::NoDetails());
343
[email protected]1e5e74f2009-05-27 20:55:12344 // Notify any lasting InfobarDelegates that have not yet been removed that
345 // whatever infobar they were handling in this TabContents has closed,
346 // because the TabContents is going away entirely.
347 // This must happen after the TAB_CONTENTS_DESTROYED notification as the
348 // notification may trigger infobars calls that access their delegate. (and
349 // some implementations of InfoBarDelegate do delete themselves on
350 // InfoBarClosed()).
351 for (int i = 0; i < infobar_delegate_count(); ++i) {
352 InfoBarDelegate* delegate = GetInfoBarDelegateAt(i);
353 delegate->InfoBarClosed();
354 }
355 infobar_delegates_.clear();
356
[email protected]420ae012009-04-24 05:16:32357 // TODO(brettw) this should be moved to the view.
358#if defined(OS_WIN)
359 // If we still have a window handle, destroy it. GetNativeView can return
360 // NULL if this contents was part of a window that closed.
361 if (GetNativeView())
362 ::DestroyWindow(GetNativeView());
363#endif
[email protected]7ab1e7d62009-10-14 23:32:01364
365 // OnCloseStarted isn't called in unit tests.
366 if (!tab_close_start_time_.is_null()) {
367 UMA_HISTOGRAM_TIMES("Tab.Close",
368 base::TimeTicks::Now() - tab_close_start_time_);
369 }
initial.commit09911bf2008-07-26 23:55:29370}
371
[email protected]d5f942ba2008-09-26 19:30:34372// static
373void TabContents::RegisterUserPrefs(PrefService* prefs) {
[email protected]420ae012009-04-24 05:16:32374 prefs->RegisterBooleanPref(prefs::kAlternateErrorPagesEnabled, true);
375
376 WebPreferences pref_defaults;
377 prefs->RegisterBooleanPref(prefs::kWebKitJavascriptEnabled,
378 pref_defaults.javascript_enabled);
379 prefs->RegisterBooleanPref(prefs::kWebKitWebSecurityEnabled,
380 pref_defaults.web_security_enabled);
381 prefs->RegisterBooleanPref(
382 prefs::kWebKitJavascriptCanOpenWindowsAutomatically, true);
383 prefs->RegisterBooleanPref(prefs::kWebKitLoadsImagesAutomatically,
384 pref_defaults.loads_images_automatically);
385 prefs->RegisterBooleanPref(prefs::kWebKitPluginsEnabled,
386 pref_defaults.plugins_enabled);
387 prefs->RegisterBooleanPref(prefs::kWebKitDomPasteEnabled,
388 pref_defaults.dom_paste_enabled);
389 prefs->RegisterBooleanPref(prefs::kWebKitShrinksStandaloneImagesToFit,
390 pref_defaults.shrinks_standalone_images_to_fit);
[email protected]0df30122009-06-03 12:13:08391 prefs->RegisterStringPref(prefs::kWebKitInspectorSettings,
[email protected]8922e1f2009-10-03 05:01:26392 UTF8ToWide(pref_defaults.inspector_settings));
[email protected]420ae012009-04-24 05:16:32393 prefs->RegisterBooleanPref(prefs::kWebKitTextAreasAreResizable,
394 pref_defaults.text_areas_are_resizable);
395 prefs->RegisterBooleanPref(prefs::kWebKitJavaEnabled,
396 pref_defaults.java_enabled);
397
398 prefs->RegisterLocalizedStringPref(prefs::kAcceptLanguages,
399 IDS_ACCEPT_LANGUAGES);
400 prefs->RegisterLocalizedStringPref(prefs::kDefaultCharset,
401 IDS_DEFAULT_ENCODING);
402 prefs->RegisterLocalizedBooleanPref(prefs::kWebKitStandardFontIsSerif,
403 IDS_STANDARD_FONT_IS_SERIF);
404 prefs->RegisterLocalizedStringPref(prefs::kWebKitFixedFontFamily,
405 IDS_FIXED_FONT_FAMILY);
406 prefs->RegisterLocalizedStringPref(prefs::kWebKitSerifFontFamily,
407 IDS_SERIF_FONT_FAMILY);
408 prefs->RegisterLocalizedStringPref(prefs::kWebKitSansSerifFontFamily,
409 IDS_SANS_SERIF_FONT_FAMILY);
410 prefs->RegisterLocalizedStringPref(prefs::kWebKitCursiveFontFamily,
411 IDS_CURSIVE_FONT_FAMILY);
412 prefs->RegisterLocalizedStringPref(prefs::kWebKitFantasyFontFamily,
413 IDS_FANTASY_FONT_FAMILY);
414 prefs->RegisterLocalizedIntegerPref(prefs::kWebKitDefaultFontSize,
415 IDS_DEFAULT_FONT_SIZE);
416 prefs->RegisterLocalizedIntegerPref(prefs::kWebKitDefaultFixedFontSize,
417 IDS_DEFAULT_FIXED_FONT_SIZE);
418 prefs->RegisterLocalizedIntegerPref(prefs::kWebKitMinimumFontSize,
419 IDS_MINIMUM_FONT_SIZE);
420 prefs->RegisterLocalizedIntegerPref(prefs::kWebKitMinimumLogicalFontSize,
421 IDS_MINIMUM_LOGICAL_FONT_SIZE);
422 prefs->RegisterLocalizedBooleanPref(prefs::kWebKitUsesUniversalDetector,
423 IDS_USES_UNIVERSAL_DETECTOR);
424 prefs->RegisterLocalizedStringPref(prefs::kStaticEncodings,
425 IDS_STATIC_ENCODING_LIST);
initial.commit09911bf2008-07-26 23:55:29426}
427
[email protected]13367f72009-07-08 16:39:02428// Returns true if contains content rendered by an extension.
429bool TabContents::HostsExtension() const {
430 return GetURL().SchemeIs(chrome::kExtensionScheme);
[email protected]d5f942ba2008-09-26 19:30:34431}
432
[email protected]6e95706d2009-04-23 22:55:01433PasswordManager* TabContents::GetPasswordManager() {
434 if (password_manager_.get() == NULL)
435 password_manager_.reset(new PasswordManager(this));
436 return password_manager_.get();
437}
438
439PluginInstaller* TabContents::GetPluginInstaller() {
440 if (plugin_installer_.get() == NULL)
441 plugin_installer_.reset(new PluginInstaller(this));
442 return plugin_installer_.get();
443}
444
[email protected]d5f942ba2008-09-26 19:30:34445const GURL& TabContents::GetURL() const {
446 // We may not have a navigation entry yet
[email protected]ce3fa3c2009-04-20 19:55:57447 NavigationEntry* entry = controller_.GetActiveEntry();
[email protected]ebe89e062009-08-13 23:16:54448 return entry ? entry->virtual_url() : GURL::EmptyGURL();
[email protected]d5f942ba2008-09-26 19:30:34449}
450
[email protected]96d185d2009-04-24 03:28:54451const string16& TabContents::GetTitle() const {
[email protected]4c6092c5b2009-06-06 00:23:55452 // Transient entries take precedence. They are used for interstitial pages
453 // that are shown on top of existing pages.
454 NavigationEntry* entry = controller_.GetTransientEntry();
455 if (entry)
456 return entry->GetTitleForDisplay(&controller_);
457
[email protected]96d185d2009-04-24 03:28:54458 DOMUI* our_dom_ui = render_manager_.pending_dom_ui() ?
459 render_manager_.pending_dom_ui() : render_manager_.dom_ui();
460 if (our_dom_ui) {
461 // Don't override the title in view source mode.
[email protected]4c6092c5b2009-06-06 00:23:55462 entry = controller_.GetActiveEntry();
[email protected]96d185d2009-04-24 03:28:54463 if (!(entry && entry->IsViewSourceMode())) {
464 // Give the DOM UI the chance to override our title.
465 const string16& title = our_dom_ui->overridden_title();
466 if (!title.empty())
467 return title;
468 }
469 }
470
471 // We use the title for the last committed entry rather than a pending
472 // navigation entry. For example, when the user types in a URL, we want to
473 // keep the old page's title until the new load has committed and we get a new
474 // title.
[email protected]96d185d2009-04-24 03:28:54475 entry = controller_.GetLastCommittedEntry();
476 if (entry)
477 return entry->GetTitleForDisplay(&controller_);
[email protected]96d185d2009-04-24 03:28:54478 return EmptyString16();
479}
480
[email protected]d5f942ba2008-09-26 19:30:34481int32 TabContents::GetMaxPageID() {
482 if (GetSiteInstance())
483 return GetSiteInstance()->max_page_id();
484 else
485 return max_page_id_;
486}
487
488void TabContents::UpdateMaxPageID(int32 page_id) {
489 // Ensure both the SiteInstance and RenderProcessHost update their max page
[email protected]57c6a652009-05-04 07:58:34490 // IDs in sync. Only TabContents will also have site instances, except during
[email protected]d5f942ba2008-09-26 19:30:34491 // testing.
492 if (GetSiteInstance())
493 GetSiteInstance()->UpdateMaxPageID(page_id);
[email protected]57c6a652009-05-04 07:58:34494 process()->UpdateMaxPageID(page_id);
[email protected]d5f942ba2008-09-26 19:30:34495}
496
[email protected]96d185d2009-04-24 03:28:54497SiteInstance* TabContents::GetSiteInstance() const {
498 return render_manager_.current_host()->site_instance();
499}
500
[email protected]d5f942ba2008-09-26 19:30:34501const std::wstring TabContents::GetDefaultTitle() const {
502 return l10n_util::GetString(IDS_DEFAULT_TAB_TITLE);
503}
504
[email protected]96d185d2009-04-24 03:28:54505bool TabContents::ShouldDisplayURL() {
[email protected]8ab24cc2009-11-13 20:56:15506 // Don't hide the url in view source mode and with interstitials.
[email protected]96d185d2009-04-24 03:28:54507 NavigationEntry* entry = controller_.GetActiveEntry();
[email protected]8ab24cc2009-11-13 20:56:15508 if (entry && (entry->IsViewSourceMode() ||
509 entry->page_type() == NavigationEntry::INTERSTITIAL_PAGE)) {
[email protected]96d185d2009-04-24 03:28:54510 return true;
[email protected]8ab24cc2009-11-13 20:56:15511 }
[email protected]83e3895b2009-06-11 00:07:16512
[email protected]96d185d2009-04-24 03:28:54513 DOMUI* dom_ui = GetDOMUIForCurrentState();
514 if (dom_ui)
515 return !dom_ui->should_hide_url();
516 return true;
517}
518
[email protected]d5f942ba2008-09-26 19:30:34519SkBitmap TabContents::GetFavIcon() const {
520 // Like GetTitle(), we also want to use the favicon for the last committed
521 // entry rather than a pending navigation entry.
[email protected]ce3fa3c2009-04-20 19:55:57522 NavigationEntry* entry = controller_.GetTransientEntry();
[email protected]cbab76d2008-10-13 22:42:47523 if (entry)
524 return entry->favicon().bitmap();
525
[email protected]ce3fa3c2009-04-20 19:55:57526 entry = controller_.GetLastCommittedEntry();
[email protected]d5f942ba2008-09-26 19:30:34527 if (entry)
528 return entry->favicon().bitmap();
[email protected]d5f942ba2008-09-26 19:30:34529 return SkBitmap();
530}
531
[email protected]0b303cc2009-09-28 22:35:15532bool TabContents::FavIconIsValid() const {
533 NavigationEntry* entry = controller_.GetTransientEntry();
534 if (entry)
535 return entry->favicon().is_valid();
536
537 entry = controller_.GetLastCommittedEntry();
538 if (entry)
539 return entry->favicon().is_valid();
540
541 return false;
542}
543
[email protected]96d185d2009-04-24 03:28:54544bool TabContents::ShouldDisplayFavIcon() {
545 // Always display a throbber during pending loads.
546 if (controller_.GetLastCommittedEntry() && controller_.pending_entry())
547 return true;
548
549 DOMUI* dom_ui = GetDOMUIForCurrentState();
550 if (dom_ui)
551 return !dom_ui->hide_favicon();
552 return true;
553}
554
[email protected]96d185d2009-04-24 03:28:54555std::wstring TabContents::GetStatusText() const {
556 if (!is_loading() || load_state_ == net::LOAD_STATE_IDLE)
557 return std::wstring();
558
559 switch (load_state_) {
560 case net::LOAD_STATE_WAITING_FOR_CACHE:
561 return l10n_util::GetString(IDS_LOAD_STATE_WAITING_FOR_CACHE);
562 case net::LOAD_STATE_RESOLVING_PROXY_FOR_URL:
563 return l10n_util::GetString(IDS_LOAD_STATE_RESOLVING_PROXY_FOR_URL);
564 case net::LOAD_STATE_RESOLVING_HOST:
565 return l10n_util::GetString(IDS_LOAD_STATE_RESOLVING_HOST);
566 case net::LOAD_STATE_CONNECTING:
567 return l10n_util::GetString(IDS_LOAD_STATE_CONNECTING);
568 case net::LOAD_STATE_SENDING_REQUEST:
[email protected]094e5b22009-09-25 04:23:56569 if (upload_size_)
570 return l10n_util::GetStringF(
571 IDS_LOAD_STATE_SENDING_REQUEST_WITH_PROGRESS,
572 static_cast<int>((100 * upload_position_) / upload_size_));
573 else
574 return l10n_util::GetString(IDS_LOAD_STATE_SENDING_REQUEST);
[email protected]96d185d2009-04-24 03:28:54575 case net::LOAD_STATE_WAITING_FOR_RESPONSE:
576 return l10n_util::GetStringF(IDS_LOAD_STATE_WAITING_FOR_RESPONSE,
577 load_state_host_);
578 // Ignore net::LOAD_STATE_READING_RESPONSE and net::LOAD_STATE_IDLE
579 case net::LOAD_STATE_IDLE:
580 case net::LOAD_STATE_READING_RESPONSE:
581 break;
582 }
583
584 return std::wstring();
585}
586
[email protected]d5f942ba2008-09-26 19:30:34587void TabContents::SetIsCrashed(bool state) {
588 if (state == is_crashed_)
589 return;
590
591 is_crashed_ = state;
[email protected]c9cd2222009-05-06 05:16:50592 NotifyNavigationStateChanged(INVALIDATE_TAB);
[email protected]d5f942ba2008-09-26 19:30:34593}
594
[email protected]744ef172009-10-16 21:53:46595void TabContents::PageActionStateChanged() {
596 NotifyNavigationStateChanged(TabContents::INVALIDATE_PAGE_ACTIONS);
[email protected]d7eaf572009-07-01 21:57:00597}
[email protected]ce5c4502009-05-06 16:46:11598
[email protected]d5f942ba2008-09-26 19:30:34599void TabContents::NotifyNavigationStateChanged(unsigned changed_flags) {
600 if (delegate_)
601 delegate_->NavigationStateChanged(this, changed_flags);
602}
603
[email protected]96d185d2009-04-24 03:28:54604void TabContents::DidBecomeSelected() {
605 controller_.SetActive(true);
[email protected]789e9152009-08-04 21:59:43606 if (render_widget_host_view()) {
[email protected]96d185d2009-04-24 03:28:54607 render_widget_host_view()->DidBecomeSelected();
[email protected]789e9152009-08-04 21:59:43608#if defined(OS_MACOSX)
609 render_widget_host_view()->SetActive(true);
610#endif
611 }
[email protected]96d185d2009-04-24 03:28:54612
[email protected]76543b92009-08-31 17:27:45613 WebCacheManager::GetInstance()->ObserveActivity(process()->id());
[email protected]96d185d2009-04-24 03:28:54614}
615
616void TabContents::WasHidden() {
617 if (!capturing_contents()) {
618 // |render_view_host()| can be NULL if the user middle clicks a link to open
619 // a tab in then background, then closes the tab before selecting it. This
620 // is because closing the tab calls TabContents::Destroy(), which removes
621 // the |render_view_host()|; then when we actually destroy the window,
622 // OnWindowPosChanged() notices and calls HideContents() (which calls us).
623 if (render_widget_host_view())
624 render_widget_host_view()->WasHidden();
[email protected]96d185d2009-04-24 03:28:54625 }
626
627 NotificationService::current()->Notify(
628 NotificationType::TAB_CONTENTS_HIDDEN,
629 Source<TabContents>(this),
630 NotificationService::NoDetails());
631}
632
[email protected]d5f942ba2008-09-26 19:30:34633void TabContents::Activate() {
634 if (delegate_)
635 delegate_->ActivateContents(this);
636}
637
[email protected]96d185d2009-04-24 03:28:54638void TabContents::ShowContents() {
639 if (render_widget_host_view())
640 render_widget_host_view()->DidBecomeSelected();
[email protected]96d185d2009-04-24 03:28:54641}
642
643void TabContents::HideContents() {
644 // TODO(pkasting): http://b/1239839 Right now we purposefully don't call
645 // our superclass HideContents(), because some callers want to be very picky
646 // about the order in which these get called. In addition to making the code
647 // here practically impossible to understand, this also means we end up
648 // calling TabContents::WasHidden() twice if callers call both versions of
[email protected]57c6a652009-05-04 07:58:34649 // HideContents() on a TabContents.
[email protected]96d185d2009-04-24 03:28:54650 WasHidden();
651}
652
[email protected]c0588052008-10-27 23:01:50653void TabContents::OpenURL(const GURL& url, const GURL& referrer,
[email protected]d5f942ba2008-09-26 19:30:34654 WindowOpenDisposition disposition,
655 PageTransition::Type transition) {
656 if (delegate_)
[email protected]c0588052008-10-27 23:01:50657 delegate_->OpenURLFromTab(this, url, referrer, disposition, transition);
[email protected]d5f942ba2008-09-26 19:30:34658}
659
660bool TabContents::NavigateToPendingEntry(bool reload) {
[email protected]96d185d2009-04-24 03:28:54661 const NavigationEntry& entry = *controller_.pending_entry();
662
663 RenderViewHost* dest_render_view_host = render_manager_.Navigate(entry);
664 if (!dest_render_view_host)
665 return false; // Unable to create the desired render view host.
666
667 // Tell DevTools agent that it is attached prior to the navigation.
[email protected]d9f9b792009-06-24 13:17:12668 DevToolsManager* devtools_manager = DevToolsManager::GetInstance();
[email protected]7e8e6b62009-05-08 11:28:32669 if (devtools_manager) { // NULL in unit tests.
[email protected]684b4ba22009-05-07 06:27:41670 devtools_manager->OnNavigatingToPendingEntry(
671 render_view_host(),
672 dest_render_view_host,
673 controller_.pending_entry()->url());
[email protected]7e8e6b62009-05-08 11:28:32674 }
[email protected]96d185d2009-04-24 03:28:54675
676 // Used for page load time metrics.
677 current_load_start_ = base::TimeTicks::Now();
678
679 // Navigate in the desired RenderViewHost.
[email protected]056de2d2009-06-26 16:41:34680 ViewMsg_Navigate_Params navigate_params;
[email protected]5e369672009-11-03 23:48:30681 MakeNavigateParams(profile(), entry, reload, &navigate_params);
[email protected]056de2d2009-06-26 16:41:34682 dest_render_view_host->Navigate(navigate_params);
[email protected]96d185d2009-04-24 03:28:54683
684 if (entry.page_id() == -1) {
685 // HACK!! This code suppresses javascript: URLs from being added to
686 // session history, which is what we want to do for javascript: URLs that
687 // do not generate content. What we really need is a message from the
688 // renderer telling us that a new page was not created. The same message
689 // could be used for mailto: URLs and the like.
690 if (entry.url().SchemeIs(chrome::kJavaScriptScheme))
691 return false;
692 }
693
694 // Clear any provisional password saves - this stops password infobars
695 // showing up on pages the user navigates to while the right page is
696 // loading.
697 GetPasswordManager()->ClearProvisionalSave();
698
699 if (reload && !profile()->IsOffTheRecord()) {
[email protected]0189bc722009-08-28 21:56:48700 FaviconService* favicon_service =
701 profile()->GetFaviconService(Profile::IMPLICIT_ACCESS);
702 if (favicon_service)
703 favicon_service->SetFaviconOutOfDateForPage(entry.url());
[email protected]96d185d2009-04-24 03:28:54704 }
705
[email protected]d5f942ba2008-09-26 19:30:34706 return true;
707}
708
[email protected]96d185d2009-04-24 03:28:54709void TabContents::Stop() {
710 render_manager_.Stop();
711 printing_.Stop();
712}
713
714void TabContents::Cut() {
715 render_view_host()->Cut();
716}
717
718void TabContents::Copy() {
719 render_view_host()->Copy();
720}
721
[email protected]c0cc3092009-09-12 08:27:27722#if defined(OS_MACOSX)
[email protected]a954bf72009-09-12 07:30:35723void TabContents::CopyToFindPboard() {
724 render_view_host()->CopyToFindPboard();
725}
[email protected]c0cc3092009-09-12 08:27:27726#endif
[email protected]a954bf72009-09-12 07:30:35727
[email protected]96d185d2009-04-24 03:28:54728void TabContents::Paste() {
729 render_view_host()->Paste();
730}
731
[email protected]7e786822009-11-07 00:00:27732#if defined(OS_MACOSX)
733void TabContents::PasteAndMatchStyle() {
734 render_view_host()->ForwardEditCommand("PasteAndMatchStyle", "");
735}
736#endif
737
[email protected]96d185d2009-04-24 03:28:54738void TabContents::DisassociateFromPopupCount() {
739 render_view_host()->DisassociateFromPopupCount();
740}
741
742TabContents* TabContents::Clone() {
743 // We create a new SiteInstance so that the new tab won't share processes
744 // with the old one. This can be changed in the future if we need it to share
745 // processes for some reason.
[email protected]420ae012009-04-24 05:16:32746 TabContents* tc = new TabContents(profile(),
[email protected]96d185d2009-04-24 03:28:54747 SiteInstance::CreateSiteInstance(profile()),
[email protected]12636df2009-09-28 22:32:21748 MSG_ROUTING_NONE, this);
[email protected]96d185d2009-04-24 03:28:54749 tc->controller().CopyStateFrom(controller_);
750 return tc;
751}
752
[email protected]4d677202009-07-19 07:37:12753void TabContents::ShowPageInfo(const GURL& url,
754 const NavigationEntry::SSLStatus& ssl,
755 bool show_history) {
756 if (!delegate_)
757 return;
758
[email protected]bb678332009-07-21 00:15:50759 delegate_->ShowPageInfo(profile(), url, ssl, show_history);
[email protected]4d677202009-07-19 07:37:12760}
761
initial.commit09911bf2008-07-26 23:55:29762ConstrainedWindow* TabContents::CreateConstrainedDialog(
[email protected]e8382172009-06-19 22:16:28763 ConstrainedWindowDelegate* delegate) {
initial.commit09911bf2008-07-26 23:55:29764 ConstrainedWindow* window =
[email protected]e8382172009-06-19 22:16:28765 ConstrainedWindow::CreateConstrainedDialog(this, delegate);
initial.commit09911bf2008-07-26 23:55:29766 child_windows_.push_back(window);
767 return window;
768}
769
770void TabContents::AddNewContents(TabContents* new_contents,
771 WindowOpenDisposition disposition,
772 const gfx::Rect& initial_pos,
[email protected]c88a70fe2009-05-05 20:00:22773 bool user_gesture,
774 const GURL& creator_url) {
initial.commit09911bf2008-07-26 23:55:29775 if (!delegate_)
776 return;
777
[email protected]35f7d212009-04-29 21:19:27778 if ((disposition == NEW_POPUP) && !user_gesture &&
779 !CommandLine::ForCurrentProcess()->HasSwitch(
780 switches::kDisablePopupBlocking)) {
[email protected]2c4410d2009-05-06 23:46:22781 // Unrequested popups from normal pages are constrained unless they're in
[email protected]b6c874582009-05-08 19:38:31782 // the whitelist. The popup owner will handle checking this.
783 delegate_->GetConstrainingContents(this)->AddPopup(new_contents,
784 initial_pos,
785 creator_url.is_valid() ? creator_url.host() : std::string());
786 } else {
[email protected]304f8792009-08-19 21:28:09787#if defined(OS_CHROMEOS)
788 if (disposition == NEW_POPUP) {
789 // If the popup is bigger than a given factor of the screen, then
790 // turn it into a foreground tab (on chrome os only)
791 GdkScreen* screen = gdk_screen_get_default();
792 int max_width = gdk_screen_get_width(screen) * kMaxWidthFactor;
793 int max_height = gdk_screen_get_height(screen) * kMaxHeightFactor;
794 if (initial_pos.width() > max_width ||
795 initial_pos.height() > max_height) {
796 disposition = NEW_FOREGROUND_TAB;
797 }
798 }
799#endif
800
[email protected]0aa55312008-10-17 21:53:08801 new_contents->DisassociateFromPopupCount();
initial.commit09911bf2008-07-26 23:55:29802 delegate_->AddNewContents(this, new_contents, disposition, initial_pos,
803 user_gesture);
[email protected]7f37dd92009-09-15 16:35:49804 NotificationService::current()->Notify(
805 NotificationType::TAB_ADDED,
806 Source<TabContentsDelegate>(delegate_),
807 Details<TabContents>(this));
initial.commit09911bf2008-07-26 23:55:29808 }
[email protected]b6c874582009-05-08 19:38:31809 PopupNotificationVisibilityChanged(ShowingBlockedPopupNotification());
initial.commit09911bf2008-07-26 23:55:29810}
811
initial.commit09911bf2008-07-26 23:55:29812void TabContents::CloseAllSuppressedPopups() {
[email protected]d6598c052008-11-05 19:03:25813 if (blocked_popups_)
[email protected]2c4410d2009-05-06 23:46:22814 blocked_popups_->CloseAll();
initial.commit09911bf2008-07-26 23:55:29815}
816
[email protected]912256b32009-09-18 09:47:35817void TabContents::ExecuteCode(int request_id, const std::string& extension_id,
[email protected]20ad2692009-11-20 18:27:20818 bool is_js_code, const std::string& code_string,
819 bool all_frames) {
[email protected]912256b32009-09-18 09:47:35820 render_view_host()->Send(
821 new ViewMsg_ExecuteCode(render_view_host()->routing_id(), request_id,
[email protected]20ad2692009-11-20 18:27:20822 extension_id, is_js_code, code_string,
823 all_frames));
[email protected]912256b32009-09-18 09:47:35824}
825
[email protected]96d185d2009-04-24 03:28:54826void TabContents::PopupNotificationVisibilityChanged(bool visible) {
827 render_view_host()->PopupNotificationVisibilityChanged(visible);
828}
829
[email protected]5c9e97a2009-09-09 23:48:30830gfx::NativeView TabContents::GetContentNativeView() const {
[email protected]96d185d2009-04-24 03:28:54831 return view_->GetContentNativeView();
832}
833
834gfx::NativeView TabContents::GetNativeView() const {
835 return view_->GetNativeView();
836}
837
838void TabContents::GetContainerBounds(gfx::Rect *out) const {
839 view_->GetContainerBounds(out);
840}
841
842void TabContents::Focus() {
843 view_->Focus();
844}
845
[email protected]90daadb42009-06-08 21:27:28846void TabContents::FocusThroughTabTraversal(bool reverse) {
[email protected]7e383692009-06-12 19:14:54847 if (showing_interstitial_page()) {
848 render_manager_.interstitial_page()->FocusThroughTabTraversal(reverse);
849 return;
850 }
[email protected]96d185d2009-04-24 03:28:54851 render_view_host()->SetInitialFocus(reverse);
852}
853
854bool TabContents::FocusLocationBarByDefault() {
855 DOMUI* dom_ui = GetDOMUIForCurrentState();
856 if (dom_ui)
857 return dom_ui->focus_location_bar_by_default();
[email protected]3e3f0eb2009-06-22 18:33:43858 NavigationEntry* entry = controller_.GetActiveEntry();
[email protected]e0d481582009-09-15 21:06:25859 if (entry && entry->url() == GURL(chrome::kAboutBlankURL))
[email protected]3e3f0eb2009-06-22 18:33:43860 return true;
[email protected]96d185d2009-04-24 03:28:54861 return false;
862}
863
[email protected]616ed5a2008-11-21 22:27:24864void TabContents::AddInfoBar(InfoBarDelegate* delegate) {
865 // Look through the existing InfoBarDelegates we have for a match. If we've
866 // already got one that matches, then we don't add the new one.
[email protected]f86a07022008-11-25 01:06:05867 for (int i = 0; i < infobar_delegate_count(); ++i) {
[email protected]616ed5a2008-11-21 22:27:24868 if (GetInfoBarDelegateAt(i)->EqualsDelegate(delegate))
869 return;
870 }
871
872 infobar_delegates_.push_back(delegate);
[email protected]bfd04a62009-02-01 18:16:56873 NotificationService::current()->Notify(
874 NotificationType::TAB_CONTENTS_INFOBAR_ADDED,
875 Source<TabContents>(this),
876 Details<InfoBarDelegate>(delegate));
[email protected]616ed5a2008-11-21 22:27:24877
878 // Add ourselves as an observer for navigations the first time a delegate is
879 // added. We use this notification to expire InfoBars that need to expire on
880 // page transitions.
881 if (infobar_delegates_.size() == 1) {
[email protected]bfd04a62009-02-01 18:16:56882 registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
[email protected]ce3fa3c2009-04-20 19:55:57883 Source<NavigationController>(&controller_));
[email protected]616ed5a2008-11-21 22:27:24884 }
885}
886
887void TabContents::RemoveInfoBar(InfoBarDelegate* delegate) {
888 std::vector<InfoBarDelegate*>::iterator it =
889 find(infobar_delegates_.begin(), infobar_delegates_.end(), delegate);
890 if (it != infobar_delegates_.end()) {
891 InfoBarDelegate* delegate = *it;
[email protected]bfd04a62009-02-01 18:16:56892 NotificationService::current()->Notify(
893 NotificationType::TAB_CONTENTS_INFOBAR_REMOVED,
894 Source<TabContents>(this),
895 Details<InfoBarDelegate>(delegate));
[email protected]f86a07022008-11-25 01:06:05896 infobar_delegates_.erase(it);
[email protected]616ed5a2008-11-21 22:27:24897
[email protected]6a02963e2009-01-06 16:58:03898 // Remove ourselves as an observer if we are tracking no more InfoBars.
899 if (infobar_delegates_.empty()) {
[email protected]bfd04a62009-02-01 18:16:56900 registrar_.Remove(this, NotificationType::NAV_ENTRY_COMMITTED,
[email protected]ce3fa3c2009-04-20 19:55:57901 Source<NavigationController>(&controller_));
[email protected]6a02963e2009-01-06 16:58:03902 }
[email protected]616ed5a2008-11-21 22:27:24903 }
904}
[email protected]3edd9522009-03-04 22:19:41905
[email protected]f81821c2009-08-07 01:29:47906void TabContents::ReplaceInfoBar(InfoBarDelegate* old_delegate,
907 InfoBarDelegate* new_delegate) {
908 std::vector<InfoBarDelegate*>::iterator it =
909 find(infobar_delegates_.begin(), infobar_delegates_.end(), old_delegate);
910 DCHECK(it != infobar_delegates_.end());
911
912 // Notify the container about the change of plans.
913 scoped_ptr<std::pair<InfoBarDelegate*, InfoBarDelegate*> > details(
914 new std::pair<InfoBarDelegate*, InfoBarDelegate*>(
915 old_delegate, new_delegate));
916 NotificationService::current()->Notify(
917 NotificationType::TAB_CONTENTS_INFOBAR_REPLACED,
918 Source<TabContents>(this),
919 Details<std::pair<InfoBarDelegate*, InfoBarDelegate*> >(details.get()));
920
921 // Remove the old one.
922 infobar_delegates_.erase(it);
923
924 // Add the new one.
925 infobar_delegates_.push_back(new_delegate);
926}
927
[email protected]20ede072009-10-06 00:28:35928bool TabContents::ShouldShowBookmarkBar() {
[email protected]aa9196f2009-10-22 16:20:27929 if (showing_interstitial_page())
930 return false;
931
[email protected]96d185d2009-04-24 03:28:54932 // See GetDOMUIForCurrentState() comment for more info. This case is very
933 // similar, but for non-first loads, we want to use the committed entry. This
934 // is so the bookmarks bar disappears at the same time the page does.
935 if (controller_.GetLastCommittedEntry()) {
936 // Not the first load, always use the committed DOM UI.
937 if (render_manager_.dom_ui())
938 return render_manager_.dom_ui()->force_bookmark_bar_visible();
939 return false; // Default.
940 }
941
942 // When it's the first load, we know either the pending one or the committed
943 // one will have the DOM UI in it (see GetDOMUIForCurrentState), and only one
944 // of them will be valid, so we can just check both.
945 if (render_manager_.pending_dom_ui())
946 return render_manager_.pending_dom_ui()->force_bookmark_bar_visible();
947 if (render_manager_.dom_ui())
948 return render_manager_.dom_ui()->force_bookmark_bar_visible();
949 return false; // Default.
950}
951
[email protected]d8f16ae2009-08-30 03:47:26952bool TabContents::IsExtensionShelfAlwaysVisible() {
953 // See GetDOMUIForCurrentState() comment for more info. This case is very
954 // similar, but for non-first loads, we want to use the committed entry. This
955 // is so the bookmarks bar disappears at the same time the page does.
956 if (controller_.GetLastCommittedEntry()) {
957 // Not the first load, always use the committed DOM UI.
958 if (render_manager_.dom_ui())
959 return render_manager_.dom_ui()->force_extension_shelf_visible();
960 return false; // Default.
961 }
962
963 // When it's the first load, we know either the pending one or the committed
964 // one will have the DOM UI in it (see GetDOMUIForCurrentState), and only one
965 // of them will be valid, so we can just check both.
966 if (render_manager_.pending_dom_ui())
967 return render_manager_.pending_dom_ui()->force_extension_shelf_visible();
968 if (render_manager_.dom_ui())
969 return render_manager_.dom_ui()->force_extension_shelf_visible();
970 return false; // Default.
971}
972
[email protected]3edd9522009-03-04 22:19:41973void TabContents::ToolbarSizeChanged(bool is_animating) {
974 TabContentsDelegate* d = delegate();
975 if (d)
976 d->ToolbarSizeChanged(this, is_animating);
977}
[email protected]616ed5a2008-11-21 22:27:24978
[email protected]fc6fb7fb2009-11-07 02:35:04979bool TabContents::CanDownload(int request_id) {
980 TabContentsDelegate* d = delegate();
981 if (d)
982 return d->CanDownload(request_id);
983 return true;
984}
985
[email protected]d5f942ba2008-09-26 19:30:34986void TabContents::OnStartDownload(DownloadItem* download) {
987 DCHECK(download);
[email protected]d5f942ba2008-09-26 19:30:34988
989 // Download in a constrained popup is shown in the tab that opened it.
[email protected]b6c874582009-05-08 19:38:31990 TabContents* tab_contents = delegate()->GetConstrainingContents(this);
[email protected]d5f942ba2008-09-26 19:30:34991
[email protected]59560e0b2009-06-04 03:30:22992 if (tab_contents && tab_contents->delegate())
993 tab_contents->delegate()->OnStartDownload(download);
[email protected]3edd9522009-03-04 22:19:41994}
[email protected]3edd9522009-03-04 22:19:41995
[email protected]d5f942ba2008-09-26 19:30:34996void TabContents::WillClose(ConstrainedWindow* window) {
997 ConstrainedWindowList::iterator it =
998 find(child_windows_.begin(), child_windows_.end(), window);
999 if (it != child_windows_.end())
1000 child_windows_.erase(it);
[email protected]66ba4932009-06-04 19:22:131001}
[email protected]d5f942ba2008-09-26 19:30:341002
[email protected]66ba4932009-06-04 19:22:131003void TabContents::WillCloseBlockedPopupContainer(
1004 BlockedPopupContainer* container) {
1005 DCHECK(blocked_popups_ == container);
1006 blocked_popups_ = NULL;
[email protected]d5f942ba2008-09-26 19:30:341007}
1008
[email protected]d5f942ba2008-09-26 19:30:341009void TabContents::DidMoveOrResize(ConstrainedWindow* window) {
[email protected]332af7732009-03-11 13:21:351010#if defined(OS_WIN)
[email protected]92edc472009-02-10 20:32:061011 UpdateWindow(GetNativeView());
[email protected]332af7732009-03-11 13:21:351012#endif
[email protected]d5f942ba2008-09-26 19:30:341013}
1014
[email protected]c1dc9f132009-11-20 23:13:211015void TabContents::StartFinding(string16 search_string,
[email protected]e491f1c2009-05-22 20:28:121016 bool forward_direction,
1017 bool case_sensitive) {
[email protected]c1dc9f132009-11-20 23:13:211018 // If search_string is empty, it means FindNext was pressed with a keyboard
[email protected]6e95706d2009-04-23 22:55:011019 // shortcut so unless we have something to search for we return early.
[email protected]c1dc9f132009-11-20 23:13:211020 if (search_string.empty() && find_text_.empty()) {
[email protected]87fae512009-12-11 02:20:211021 // Try the last thing we searched for on this tab, then the last thing
1022 // searched for on any tab.
1023 if (!previous_find_text_.empty())
1024 search_string = previous_find_text_;
1025 else if (!last_search_prepopulate_text_->empty())
1026 search_string = *last_search_prepopulate_text_;
1027 else
[email protected]e491f1c2009-05-22 20:28:121028 return;
[email protected]e491f1c2009-05-22 20:28:121029 }
[email protected]6e95706d2009-04-23 22:55:011030
[email protected]101c90e2009-10-26 21:14:441031 // Keep track of the previous search.
1032 previous_find_text_ = find_text_;
1033
[email protected]6e95706d2009-04-23 22:55:011034 // This is a FindNext operation if we are searching for the same text again,
1035 // or if the passed in search text is empty (FindNext keyboard shortcut). The
1036 // exception to this is if the Find was aborted (then we don't want FindNext
1037 // because the highlighting has been cleared and we need it to reappear). We
1038 // therefore treat FindNext after an aborted Find operation as a full fledged
1039 // Find.
[email protected]c1dc9f132009-11-20 23:13:211040 bool find_next = (find_text_ == search_string || search_string.empty()) &&
[email protected]e491f1c2009-05-22 20:28:121041 (last_search_case_sensitive_ == case_sensitive) &&
[email protected]6e95706d2009-04-23 22:55:011042 !find_op_aborted_;
1043 if (!find_next)
1044 current_find_request_id_ = find_request_id_counter_++;
1045
[email protected]c1dc9f132009-11-20 23:13:211046 if (!search_string.empty())
1047 find_text_ = search_string;
[email protected]e491f1c2009-05-22 20:28:121048 last_search_case_sensitive_ = case_sensitive;
[email protected]6e95706d2009-04-23 22:55:011049
1050 find_op_aborted_ = false;
1051
1052 // Keep track of what the last search was across the tabs.
[email protected]c1dc9f132009-11-20 23:13:211053 *last_search_prepopulate_text_ = find_text_;
[email protected]6e95706d2009-04-23 22:55:011054 render_view_host()->StartFinding(current_find_request_id_,
1055 find_text_,
1056 forward_direction,
[email protected]e491f1c2009-05-22 20:28:121057 case_sensitive,
[email protected]6e95706d2009-04-23 22:55:011058 find_next);
1059}
1060
1061void TabContents::StopFinding(bool clear_selection) {
[email protected]2d2dffc2009-06-09 21:41:001062 // When |clear_selection| is true, it means the find string has been cleared
1063 // by the user, but the UI has not been dismissed.
1064 if (!clear_selection)
1065 find_ui_active_ = false;
[email protected]87fae512009-12-11 02:20:211066 previous_find_text_ = find_text_;
[email protected]101c90e2009-10-26 21:14:441067 find_text_.clear();
[email protected]6e95706d2009-04-23 22:55:011068 find_op_aborted_ = true;
[email protected]e491f1c2009-05-22 20:28:121069 last_search_result_ = FindNotificationDetails();
[email protected]6e95706d2009-04-23 22:55:011070 render_view_host()->StopFinding(clear_selection);
1071}
1072
[email protected]f3458762009-12-17 20:17:001073void TabContents::GetPageLanguage() {
1074 render_view_host()->GetPageLanguage();
1075}
1076
[email protected]420ae012009-04-24 05:16:321077void TabContents::OnSavePage() {
1078 // If we can not save the page, try to download it.
1079 if (!SavePackage::IsSavableContents(contents_mime_type())) {
1080 DownloadManager* dlm = profile()->GetDownloadManager();
1081 const GURL& current_page_url = GetURL();
1082 if (dlm && current_page_url.is_valid())
[email protected]d82ed61e2009-06-16 02:46:221083 dlm->DownloadUrl(current_page_url, GURL(), "", this);
[email protected]420ae012009-04-24 05:16:321084 return;
1085 }
1086
1087 Stop();
1088
1089 // Create the save package and possibly prompt the user for the name to save
1090 // the page as. The user prompt is an asynchronous operation that runs on
1091 // another thread.
[email protected]d82ed61e2009-06-16 02:46:221092 save_package_ = new SavePackage(this);
[email protected]420ae012009-04-24 05:16:321093 save_package_->GetSaveInfo();
1094}
1095
1096// Used in automated testing to bypass prompting the user for file names.
1097// Instead, the names and paths are hard coded rather than running them through
1098// file name sanitation and extension / mime checking.
[email protected]828cabe2009-09-26 22:47:111099bool TabContents::SavePage(const FilePath& main_file, const FilePath& dir_path,
[email protected]420ae012009-04-24 05:16:321100 SavePackage::SavePackageType save_type) {
1101 // Stop the page from navigating.
1102 Stop();
1103
[email protected]828cabe2009-09-26 22:47:111104 save_package_ = new SavePackage(this, save_type, main_file, dir_path);
[email protected]cdf6cc82009-08-04 21:48:591105 return save_package_->Init();
[email protected]420ae012009-04-24 05:16:321106}
1107
[email protected]89d6e6e2009-12-03 23:06:511108void TabContents::EmailPageLocation() {
1109 std::string title = EscapeQueryParamValue(UTF16ToUTF8(GetTitle()), false);
1110 std::string page_url = EscapeQueryParamValue(GetURL().spec(), false);
1111 std::string mailto = std::string("mailto:?subject=Fwd:%20") +
1112 title + "&body=%0A%0A" + page_url;
1113 platform_util::OpenExternal(GURL(mailto));
1114}
1115
[email protected]420ae012009-04-24 05:16:321116void TabContents::PrintPreview() {
1117 // We don't show the print preview yet, only the print dialog.
1118 PrintNow();
1119}
1120
1121bool TabContents::PrintNow() {
1122 // We can't print interstitial page for now.
1123 if (showing_interstitial_page())
1124 return false;
1125
1126 return render_view_host()->PrintPages();
1127}
1128
[email protected]82270452009-06-19 15:58:011129void TabContents::PrintingDone(int document_cookie, bool success) {
1130 render_view_host()->PrintingDone(document_cookie, success);
1131}
1132
[email protected]420ae012009-04-24 05:16:321133bool TabContents::IsActiveEntry(int32 page_id) {
1134 NavigationEntry* active_entry = controller_.GetActiveEntry();
1135 return (active_entry != NULL &&
1136 active_entry->site_instance() == GetSiteInstance() &&
1137 active_entry->page_id() == page_id);
1138}
1139
[email protected]3f8eb7f2009-10-02 23:58:051140void TabContents::LogNewTabTime(const std::string& event_name) {
1141 // Not all new tab pages get timed. In those cases, we don't have a
1142 // new_tab_start_time_.
1143 if (new_tab_start_time_.is_null())
1144 return;
1145
1146 base::TimeDelta duration = base::TimeTicks::Now() - new_tab_start_time_;
[email protected]84abba62009-10-07 17:01:441147 MetricEventDurationDetails details(event_name,
1148 static_cast<int>(duration.InMilliseconds()));
1149
[email protected]7ab1e7d62009-10-14 23:32:011150 if (event_name == "Tab.NewTabScriptStart") {
1151 UMA_HISTOGRAM_TIMES("Tab.NewTabScriptStart", duration);
1152 } else if (event_name == "Tab.NewTabDOMContentLoaded") {
1153 UMA_HISTOGRAM_TIMES("Tab.NewTabDOMContentLoaded", duration);
1154 } else if (event_name == "Tab.NewTabOnload") {
1155 UMA_HISTOGRAM_TIMES("Tab.NewTabOnload", duration);
[email protected]3f8eb7f2009-10-02 23:58:051156 // The new tab page has finished loading; reset it.
1157 new_tab_start_time_ = base::TimeTicks();
[email protected]84abba62009-10-07 17:01:441158 } else {
1159 NOTREACHED();
[email protected]3f8eb7f2009-10-02 23:58:051160 }
[email protected]84abba62009-10-07 17:01:441161 NotificationService::current()->Notify(
1162 NotificationType::METRIC_EVENT_DURATION,
1163 Source<TabContents>(this),
1164 Details<MetricEventDurationDetails>(&details));
[email protected]3f8eb7f2009-10-02 23:58:051165}
1166
[email protected]7ab1e7d62009-10-14 23:32:011167void TabContents::OnCloseStarted() {
1168 if (tab_close_start_time_.is_null())
1169 tab_close_start_time_ = base::TimeTicks::Now();
1170}
1171
[email protected]96d185d2009-04-24 03:28:541172// Notifies the RenderWidgetHost instance about the fact that the page is
1173// loading, or done loading and calls the base implementation.
1174void TabContents::SetIsLoading(bool is_loading,
1175 LoadNotificationDetails* details) {
1176 if (is_loading == is_loading_)
1177 return;
1178
1179 if (!is_loading) {
1180 load_state_ = net::LOAD_STATE_IDLE;
1181 load_state_host_.clear();
[email protected]094e5b22009-09-25 04:23:561182 upload_size_ = 0;
1183 upload_position_ = 0;
[email protected]96d185d2009-04-24 03:28:541184 }
1185
1186 render_manager_.SetIsLoading(is_loading);
1187
1188 is_loading_ = is_loading;
1189 waiting_for_response_ = is_loading;
1190
1191 if (delegate_)
1192 delegate_->LoadingStateChanged(this);
[email protected]329581b2009-04-28 06:52:351193 NotifyNavigationStateChanged(INVALIDATE_LOAD);
[email protected]96d185d2009-04-24 03:28:541194
1195 NotificationType type = is_loading ? NotificationType::LOAD_START :
1196 NotificationType::LOAD_STOP;
[email protected]ce5c4502009-05-06 16:46:111197 NotificationDetails det = NotificationService::NoDetails();
[email protected]96d185d2009-04-24 03:28:541198 if (details)
1199 det = Details<LoadNotificationDetails>(details);
1200 NotificationService::current()->Notify(type,
1201 Source<NavigationController>(&controller_),
1202 det);
1203}
1204
[email protected]2c4410d2009-05-06 23:46:221205void TabContents::CreateBlockedPopupContainerIfNecessary() {
1206 if (blocked_popups_)
1207 return;
1208
[email protected]4d4c0b92009-06-08 23:13:011209 blocked_popups_ = BlockedPopupContainer::Create(this, profile());
[email protected]2c4410d2009-05-06 23:46:221210}
1211
[email protected]b6c874582009-05-08 19:38:311212void TabContents::AddPopup(TabContents* new_contents,
1213 const gfx::Rect& initial_pos,
1214 const std::string& host) {
[email protected]2c4410d2009-05-06 23:46:221215 CreateBlockedPopupContainerIfNecessary();
1216 blocked_popups_->AddTabContents(new_contents, initial_pos, host);
[email protected]2c4410d2009-05-06 23:46:221217}
1218
[email protected]e69bce3dd2009-04-20 22:05:121219// TODO(brettw) This should be on the TabContentsView.
[email protected]66ba4932009-06-04 19:22:131220void TabContents::RepositionSupressedPopupsToFit() {
[email protected]d6598c052008-11-05 19:03:251221 if (blocked_popups_)
[email protected]4d4c0b92009-06-08 23:13:011222 blocked_popups_->RepositionBlockedPopupContainer();
[email protected]d5f942ba2008-09-26 19:30:341223}
1224
[email protected]b9681312008-11-07 00:08:261225bool TabContents::ShowingBlockedPopupNotification() const {
1226 return blocked_popups_ != NULL &&
[email protected]2c4410d2009-05-06 23:46:221227 blocked_popups_->GetBlockedPopupCount() != 0;
[email protected]b9681312008-11-07 00:08:261228}
[email protected]616ed5a2008-11-21 22:27:241229
1230namespace {
1231bool TransitionIsReload(PageTransition::Type transition) {
1232 return PageTransition::StripQualifier(transition) == PageTransition::RELOAD;
1233}
1234}
1235
1236void TabContents::ExpireInfoBars(
1237 const NavigationController::LoadCommittedDetails& details) {
1238 // Only hide InfoBars when the user has done something that makes the main
1239 // frame load. We don't want various automatic or subframe navigations making
1240 // it disappear.
1241 if (!details.is_user_initiated_main_frame_load())
1242 return;
1243
[email protected]f86a07022008-11-25 01:06:051244 for (int i = infobar_delegate_count() - 1; i >= 0; --i) {
[email protected]616ed5a2008-11-21 22:27:241245 InfoBarDelegate* delegate = GetInfoBarDelegateAt(i);
[email protected]f86a07022008-11-25 01:06:051246 if (delegate->ShouldExpire(details))
[email protected]616ed5a2008-11-21 22:27:241247 RemoveInfoBar(delegate);
[email protected]616ed5a2008-11-21 22:27:241248 }
1249}
[email protected]fdd61c62009-04-22 19:22:571250
[email protected]96d185d2009-04-24 03:28:541251DOMUI* TabContents::GetDOMUIForCurrentState() {
1252 // When there is a pending navigation entry, we want to use the pending DOMUI
1253 // that goes along with it to control the basic flags. For example, we want to
1254 // show the pending URL in the URL bar, so we want the display_url flag to
1255 // be from the pending entry.
1256 //
1257 // The confusion comes because there are multiple possibilities for the
1258 // initial load in a tab as a side effect of the way the RenderViewHostManager
1259 // works.
1260 //
1261 // - For the very first tab the load looks "normal". The new tab DOM UI is
1262 // the pending one, and we want it to apply here.
1263 //
1264 // - For subsequent new tabs, they'll get a new SiteInstance which will then
1265 // get switched to the one previously associated with the new tab pages.
1266 // This switching will cause the manager to commit the RVH/DOMUI. So we'll
1267 // have a committed DOM UI in this case.
1268 //
1269 // This condition handles all of these cases:
1270 //
1271 // - First load in first tab: no committed nav entry + pending nav entry +
1272 // pending dom ui:
1273 // -> Use pending DOM UI if any.
1274 //
1275 // - First load in second tab: no committed nav entry + pending nav entry +
1276 // no pending DOM UI:
1277 // -> Use the committed DOM UI if any.
1278 //
1279 // - Second navigation in any tab: committed nav entry + pending nav entry:
1280 // -> Use pending DOM UI if any.
1281 //
1282 // - Normal state with no load: committed nav entry + no pending nav entry:
1283 // -> Use committed DOM UI.
1284 if (controller_.pending_entry() &&
1285 (controller_.GetLastCommittedEntry() ||
1286 render_manager_.pending_dom_ui()))
1287 return render_manager_.pending_dom_ui();
1288 return render_manager_.dom_ui();
1289}
[email protected]420ae012009-04-24 05:16:321290
1291void TabContents::DidNavigateMainFramePostCommit(
1292 const NavigationController::LoadCommittedDetails& details,
1293 const ViewHostMsg_FrameNavigate_Params& params) {
[email protected]c2e74fe82009-09-03 17:57:441294 if (opener_dom_ui_type_ != DOMUIFactory::kNoDOMUI) {
1295 // If this is a window.open navigation, use the same DOMUI as the renderer
1296 // that opened the window, as long as both renderers have the same
1297 // privileges.
1298 if (opener_dom_ui_type_ == DOMUIFactory::GetDOMUIType(GetURL())) {
1299 DOMUI* dom_ui = DOMUIFactory::CreateDOMUIForURL(this, GetURL());
1300 // dom_ui might be NULL if the URL refers to a non-existent extension.
1301 if (dom_ui) {
1302 render_manager_.SetDOMUIPostCommit(dom_ui);
1303 dom_ui->RenderViewCreated(render_view_host());
1304 }
1305 }
1306 opener_dom_ui_type_ = DOMUIFactory::kNoDOMUI;
1307 }
1308
[email protected]420ae012009-04-24 05:16:321309 if (details.is_user_initiated_main_frame_load()) {
1310 // Clear the status bubble. This is a workaround for a bug where WebKit
1311 // doesn't let us know that the cursor left an element during a
1312 // transition (this is also why the mouse cursor remains as a hand after
1313 // clicking on a link); see bugs 1184641 and 980803. We don't want to
1314 // clear the bubble when a user navigates to a named anchor in the same
1315 // page.
1316 UpdateTargetURL(details.entry->page_id(), GURL());
1317
1318 // UpdateHelpersForDidNavigate will handle the case where the password_form
1319 // origin is valid.
1320 // TODO(brettw) bug 1343111: Password manager stuff in here needs to be
1321 // cleaned up and covered by tests.
1322 if (!params.password_form.origin.is_valid())
1323 GetPasswordManager()->DidNavigate();
1324 }
1325
1326 // The keyword generator uses the navigation entries, so must be called after
1327 // the commit.
1328 GenerateKeywordIfNecessary(params);
1329
1330 // Allow the new page to set the title again.
1331 received_page_title_ = false;
1332
1333 // Get the favicon, either from history or request it from the net.
1334 fav_icon_helper_.FetchFavIcon(details.entry->url());
1335
[email protected]56ce6e52009-10-27 00:10:521336 // Clear all page and browser action state for this tab, unless this is an
1337 // in-page navigation.
[email protected]92c6f9b92009-10-24 04:35:081338 url_canon::Replacements<char> replacements;
1339 replacements.ClearRef();
1340 if (params.url.ReplaceComponents(replacements) !=
1341 params.referrer.ReplaceComponents(replacements)) {
[email protected]92c6f9b92009-10-24 04:35:081342 ExtensionsService* service = profile()->GetExtensionsService();
1343 if (service) {
1344 for (size_t i = 0; i < service->extensions()->size(); ++i) {
[email protected]5d246db22009-10-27 06:17:571345 ExtensionAction* browser_action =
[email protected]92c6f9b92009-10-24 04:35:081346 service->extensions()->at(i)->browser_action();
[email protected]56ce6e52009-10-27 00:10:521347 if (browser_action) {
1348 browser_action->ClearAllValuesForTab(controller().session_id().id());
1349 NotificationService::current()->Notify(
1350 NotificationType::EXTENSION_BROWSER_ACTION_UPDATED,
[email protected]5d246db22009-10-27 06:17:571351 Source<ExtensionAction>(browser_action),
[email protected]56ce6e52009-10-27 00:10:521352 NotificationService::NoDetails());
1353 }
[email protected]92c6f9b92009-10-24 04:35:081354
[email protected]5d246db22009-10-27 06:17:571355 ExtensionAction* page_action =
[email protected]56ce6e52009-10-27 00:10:521356 service->extensions()->at(i)->page_action();
1357 if (page_action) {
1358 page_action->ClearAllValuesForTab(controller().session_id().id());
1359 PageActionStateChanged();
1360 }
[email protected]92c6f9b92009-10-24 04:35:081361 }
[email protected]aece2c7f2009-08-27 20:43:171362 }
1363 }
[email protected]ce5c4502009-05-06 16:46:111364
[email protected]420ae012009-04-24 05:16:321365 // Close constrained popups if necessary.
1366 MaybeCloseChildWindows(details.previous_url, details.entry->url());
1367
1368 // Update the starred state.
1369 UpdateStarredStateForCurrentURL();
1370}
1371
1372void TabContents::DidNavigateAnyFramePostCommit(
1373 RenderViewHost* render_view_host,
1374 const NavigationController::LoadCommittedDetails& details,
1375 const ViewHostMsg_FrameNavigate_Params& params) {
1376 // If we navigate, start showing messages again. This does nothing to prevent
1377 // a malicious script from spamming messages, since the script could just
1378 // reload the page to stop blocking.
1379 suppress_javascript_messages_ = false;
1380
[email protected]420ae012009-04-24 05:16:321381 // Notify the password manager of the navigation or form submit.
1382 // TODO(brettw) bug 1343111: Password manager stuff in here needs to be
1383 // cleaned up and covered by tests.
1384 if (params.password_form.origin.is_valid())
1385 GetPasswordManager()->ProvisionallySavePassword(params.password_form);
1386}
1387
1388void TabContents::MaybeCloseChildWindows(const GURL& previous_url,
1389 const GURL& current_url) {
1390 if (net::RegistryControlledDomainService::SameDomainOrHost(
1391 previous_url, current_url))
1392 return;
1393
1394 // Clear out any child windows since we are leaving this page entirely.
1395 // We use indices instead of iterators in case CloseWindow does something
1396 // that may invalidate an iterator.
1397 int size = static_cast<int>(child_windows_.size());
1398 for (int i = size - 1; i >= 0; --i) {
1399 ConstrainedWindow* window = child_windows_[i];
1400 if (window)
1401 window->CloseConstrainedWindow();
1402 }
[email protected]e29300cd2009-07-23 21:14:591403
1404 // Close the popup container.
1405 if (blocked_popups_) {
1406 blocked_popups_->Destroy();
1407 blocked_popups_ = NULL;
1408 }
[email protected]420ae012009-04-24 05:16:321409}
1410
1411void TabContents::UpdateStarredStateForCurrentURL() {
1412 BookmarkModel* model = profile()->GetBookmarkModel();
1413 const bool old_state = is_starred_;
1414 is_starred_ = (model && model->IsBookmarked(GetURL()));
1415
1416 if (is_starred_ != old_state && delegate())
1417 delegate()->URLStarredChanged(this, is_starred_);
1418}
1419
1420void TabContents::UpdateAlternateErrorPageURL() {
1421 GURL url = GetAlternateErrorPageURL();
1422 render_view_host()->SetAlternateErrorPageURL(url);
1423}
1424
1425void TabContents::UpdateWebPreferences() {
1426 render_view_host()->UpdateWebPreferences(GetWebkitPrefs());
1427}
1428
1429void TabContents::UpdateMaxPageIDIfNecessary(SiteInstance* site_instance,
1430 RenderViewHost* rvh) {
1431 // If we are creating a RVH for a restored controller, then we might
1432 // have more page IDs than the SiteInstance's current max page ID. We must
1433 // make sure that the max page ID is larger than any restored page ID.
1434 // Note that it is ok for conflicting page IDs to exist in another tab
1435 // (i.e., NavigationController), but if any page ID is larger than the max,
1436 // the back/forward list will get confused.
1437 int max_restored_page_id = controller_.max_restored_page_id();
1438 if (max_restored_page_id > 0) {
1439 int curr_max_page_id = site_instance->max_page_id();
1440 if (max_restored_page_id > curr_max_page_id) {
1441 // Need to update the site instance immediately.
1442 site_instance->UpdateMaxPageID(max_restored_page_id);
1443
1444 // Also tell the renderer to update its internal representation. We
1445 // need to reserve enough IDs to make all restored page IDs less than
1446 // the max.
1447 if (curr_max_page_id < 0)
1448 curr_max_page_id = 0;
1449 rvh->ReservePageIDRange(max_restored_page_id - curr_max_page_id);
1450 }
1451 }
1452}
1453
1454void TabContents::UpdateHistoryForNavigation(
[email protected]ebe89e062009-08-13 23:16:541455 const GURL& virtual_url,
[email protected]befd8d822009-07-01 04:51:471456 const NavigationController::LoadCommittedDetails& details,
[email protected]420ae012009-04-24 05:16:321457 const ViewHostMsg_FrameNavigate_Params& params) {
1458 if (profile()->IsOffTheRecord())
1459 return;
1460
1461 // Add to history service.
1462 HistoryService* hs = profile()->GetHistoryService(Profile::IMPLICIT_ACCESS);
1463 if (hs) {
1464 if (PageTransition::IsMainFrame(params.transition) &&
[email protected]ebe89e062009-08-13 23:16:541465 virtual_url != params.url) {
1466 // Hack on the "virtual" URL so that it will appear in history. For some
[email protected]420ae012009-04-24 05:16:321467 // types of URLs, we will display a magic URL that is different from where
1468 // the page is actually navigated. We want the user to see in history
[email protected]ebe89e062009-08-13 23:16:541469 // what they saw in the URL bar, so we add the virtual URL as a redirect.
1470 // This only applies to the main frame, as the virtual URL doesn't apply
[email protected]420ae012009-04-24 05:16:321471 // to sub-frames.
1472 std::vector<GURL> redirects = params.redirects;
1473 if (!redirects.empty())
[email protected]ebe89e062009-08-13 23:16:541474 redirects.back() = virtual_url;
1475 hs->AddPage(virtual_url, this, params.page_id, params.referrer,
[email protected]befd8d822009-07-01 04:51:471476 params.transition, redirects, details.did_replace_entry);
[email protected]420ae012009-04-24 05:16:321477 } else {
1478 hs->AddPage(params.url, this, params.page_id, params.referrer,
[email protected]befd8d822009-07-01 04:51:471479 params.transition, params.redirects,
1480 details.did_replace_entry);
[email protected]420ae012009-04-24 05:16:321481 }
1482 }
1483}
1484
1485bool TabContents::UpdateTitleForEntry(NavigationEntry* entry,
1486 const std::wstring& title) {
1487 // For file URLs without a title, use the pathname instead. In the case of a
1488 // synthesized title, we don't want the update to count toward the "one set
1489 // per page of the title to history."
1490 std::wstring final_title;
1491 bool explicit_set;
1492 if (entry->url().SchemeIsFile() && title.empty()) {
1493 final_title = UTF8ToWide(entry->url().ExtractFileName());
1494 explicit_set = false; // Don't count synthetic titles toward the set limit.
1495 } else {
1496 TrimWhitespace(title, TRIM_ALL, &final_title);
1497 explicit_set = true;
1498 }
1499
1500 if (final_title == UTF16ToWideHack(entry->title()))
1501 return false; // Nothing changed, don't bother.
1502
1503 entry->set_title(WideToUTF16Hack(final_title));
1504
1505 // Update the history system for this page.
1506 if (!profile()->IsOffTheRecord() && !received_page_title_) {
1507 HistoryService* hs =
1508 profile()->GetHistoryService(Profile::IMPLICIT_ACCESS);
1509 if (hs)
[email protected]ebe89e062009-08-13 23:16:541510 hs->SetPageTitle(entry->virtual_url(), final_title);
[email protected]420ae012009-04-24 05:16:321511
1512 // Don't allow the title to be saved again for explicitly set ones.
1513 received_page_title_ = explicit_set;
1514 }
1515
1516 // Lastly, set the title for the view.
1517 view_->SetPageTitle(final_title);
1518
1519 return true;
1520}
1521
1522void TabContents::NotifySwapped() {
1523 // After sending out a swap notification, we need to send a disconnect
1524 // notification so that clients that pick up a pointer to |this| can NULL the
1525 // pointer. See Bug 1230284.
1526 notify_disconnection_ = true;
1527 NotificationService::current()->Notify(
[email protected]57c6a652009-05-04 07:58:341528 NotificationType::TAB_CONTENTS_SWAPPED,
[email protected]d82ed61e2009-06-16 02:46:221529 Source<TabContents>(this),
[email protected]420ae012009-04-24 05:16:321530 NotificationService::NoDetails());
1531}
1532
1533void TabContents::NotifyConnected() {
1534 notify_disconnection_ = true;
1535 NotificationService::current()->Notify(
[email protected]57c6a652009-05-04 07:58:341536 NotificationType::TAB_CONTENTS_CONNECTED,
[email protected]d82ed61e2009-06-16 02:46:221537 Source<TabContents>(this),
[email protected]420ae012009-04-24 05:16:321538 NotificationService::NoDetails());
1539}
1540
1541void TabContents::NotifyDisconnected() {
1542 if (!notify_disconnection_)
1543 return;
1544
1545 notify_disconnection_ = false;
1546 NotificationService::current()->Notify(
[email protected]57c6a652009-05-04 07:58:341547 NotificationType::TAB_CONTENTS_DISCONNECTED,
[email protected]d82ed61e2009-06-16 02:46:221548 Source<TabContents>(this),
[email protected]420ae012009-04-24 05:16:321549 NotificationService::NoDetails());
1550}
1551
1552void TabContents::GenerateKeywordIfNecessary(
1553 const ViewHostMsg_FrameNavigate_Params& params) {
1554 if (!params.searchable_form_url.is_valid())
1555 return;
1556
1557 if (profile()->IsOffTheRecord())
1558 return;
1559
1560 int last_index = controller_.last_committed_entry_index();
1561 // When there was no previous page, the last index will be 0. This is
1562 // normally due to a form submit that opened in a new tab.
1563 // TODO(brettw) bug 916126: we should support keywords when form submits
1564 // happen in new tabs.
1565 if (last_index <= 0)
1566 return;
1567 const NavigationEntry* previous_entry =
1568 controller_.GetEntryAtIndex(last_index - 1);
1569 if (IsFormSubmit(previous_entry)) {
1570 // Only generate a keyword if the previous page wasn't itself a form
1571 // submit.
1572 return;
1573 }
1574
1575 GURL keyword_url = previous_entry->user_typed_url().is_valid() ?
1576 previous_entry->user_typed_url() : previous_entry->url();
1577 std::wstring keyword =
1578 TemplateURLModel::GenerateKeyword(keyword_url, true); // autodetected
1579 if (keyword.empty())
1580 return;
1581
1582 TemplateURLModel* url_model = profile()->GetTemplateURLModel();
1583 if (!url_model)
1584 return;
1585
1586 if (!url_model->loaded()) {
1587 url_model->Load();
1588 return;
1589 }
1590
1591 const TemplateURL* current_url;
1592 std::wstring url = UTF8ToWide(params.searchable_form_url.spec());
1593 if (!url_model->CanReplaceKeyword(keyword, url, &current_url))
1594 return;
1595
1596 if (current_url) {
1597 if (current_url->originating_url().is_valid()) {
1598 // The existing keyword was generated from an OpenSearch description
1599 // document, don't regenerate.
1600 return;
1601 }
1602 url_model->Remove(current_url);
1603 }
1604 TemplateURL* new_url = new TemplateURL();
1605 new_url->set_keyword(keyword);
1606 new_url->set_short_name(keyword);
1607 new_url->SetURL(url, 0, 0);
1608 new_url->add_input_encoding(params.searchable_form_encoding);
1609 DCHECK(controller_.GetLastCommittedEntry());
1610 const GURL& favicon_url =
1611 controller_.GetLastCommittedEntry()->favicon().url();
1612 if (favicon_url.is_valid()) {
1613 new_url->SetFavIconURL(favicon_url);
1614 } else {
1615 // The favicon url isn't valid. This means there really isn't a favicon,
1616 // or the favicon url wasn't obtained before the load started. This assumes
1617 // the later.
1618 // TODO(sky): Need a way to set the favicon that doesn't involve generating
1619 // its url.
1620 new_url->SetFavIconURL(TemplateURL::GenerateFaviconURL(params.referrer));
1621 }
1622 new_url->set_safe_for_autoreplace(true);
1623 url_model->Add(new_url);
1624}
1625
[email protected]bf5c2ff392009-07-08 16:24:331626void TabContents::OnUserGesture() {
1627 // See comment in RenderViewHostDelegate::OnUserGesture as to why we do this.
1628 DownloadRequestManager* drm = g_browser_process->download_request_manager();
1629 if (drm)
1630 drm->OnUserGesture(this);
[email protected]e7eaedde2009-09-25 20:09:491631 ExternalProtocolHandler::OnUserGesture();
[email protected]bf5c2ff392009-07-08 16:24:331632 controller_.OnUserGesture();
1633}
1634
1635void TabContents::OnFindReply(int request_id,
1636 int number_of_matches,
1637 const gfx::Rect& selection_rect,
1638 int active_match_ordinal,
1639 bool final_update) {
[email protected]3ce7ced2009-07-24 18:52:421640 // Ignore responses for requests that have been aborted.
1641 if (find_op_aborted_)
1642 return;
1643
[email protected]bf5c2ff392009-07-08 16:24:331644 // Ignore responses for requests other than the one we have most recently
1645 // issued. That way we won't act on stale results when the user has
1646 // already typed in another query.
1647 if (request_id != current_find_request_id_)
1648 return;
1649
1650 if (number_of_matches == -1)
1651 number_of_matches = last_search_result_.number_of_matches();
1652 if (active_match_ordinal == -1)
1653 active_match_ordinal = last_search_result_.active_match_ordinal();
1654
1655 gfx::Rect selection = selection_rect;
1656 if (selection.IsEmpty())
1657 selection = last_search_result_.selection_rect();
1658
1659 // Notify the UI, automation and any other observers that a find result was
1660 // found.
1661 last_search_result_ = FindNotificationDetails(request_id, number_of_matches,
1662 selection, active_match_ordinal,
1663 final_update);
1664 NotificationService::current()->Notify(
1665 NotificationType::FIND_RESULT_AVAILABLE,
1666 Source<TabContents>(this),
1667 Details<FindNotificationDetails>(&last_search_result_));
1668}
1669
1670void TabContents::GoToEntryAtOffset(int offset) {
[email protected]f9cc4c452009-10-13 14:56:381671 if (!delegate_ || delegate_->OnGoToEntryOffset(offset))
1672 controller_.GoToOffset(offset);
[email protected]bf5c2ff392009-07-08 16:24:331673}
1674
1675void TabContents::GetHistoryListCount(int* back_list_count,
1676 int* forward_list_count) {
1677 int current_index = controller_.last_committed_entry_index();
1678 *back_list_count = current_index;
1679 *forward_list_count = controller_.entry_count() - current_index - 1;
1680}
1681
1682void TabContents::OnMissingPluginStatus(int status) {
1683#if defined(OS_WIN)
1684// TODO(PORT): pull in when plug-ins work
1685 GetPluginInstaller()->OnMissingPluginStatus(status);
1686#endif
1687}
1688
1689void TabContents::OnCrashedPlugin(const FilePath& plugin_path) {
[email protected]bf5c2ff392009-07-08 16:24:331690 DCHECK(!plugin_path.value().empty());
1691
1692 std::wstring plugin_name = plugin_path.ToWStringHack();
[email protected]d32d46182009-07-23 00:09:351693#if defined(OS_WIN) || defined(OS_MACOSX)
[email protected]bf5c2ff392009-07-08 16:24:331694 scoped_ptr<FileVersionInfo> version_info(
1695 FileVersionInfo::CreateFileVersionInfo(plugin_path));
1696 if (version_info.get()) {
1697 const std::wstring& product_name = version_info->product_name();
[email protected]996fd702009-09-04 19:12:371698 if (!product_name.empty()) {
[email protected]bf5c2ff392009-07-08 16:24:331699 plugin_name = product_name;
[email protected]996fd702009-09-04 19:12:371700#if defined(OS_MACOSX)
1701 // Many plugins on the Mac have .plugin in the actual name, which looks
1702 // terrible, so look for that and strip it off if present.
1703 const std::wstring plugin_extension(L".plugin");
1704 if (EndsWith(plugin_name, plugin_extension, true))
1705 plugin_name.erase(plugin_name.length() - plugin_extension.length());
1706#endif // OS_MACOSX
1707 }
[email protected]bf5c2ff392009-07-08 16:24:331708 }
[email protected]4a560ed2009-07-13 23:35:261709#else
1710 NOTIMPLEMENTED() << " convert plugin path to plugin name";
1711#endif
[email protected]bf5c2ff392009-07-08 16:24:331712 AddInfoBar(new SimpleAlertInfoBarDelegate(
1713 this, l10n_util::GetStringF(IDS_PLUGIN_CRASHED_PROMPT, plugin_name),
1714 NULL));
[email protected]bf5c2ff392009-07-08 16:24:331715}
1716
1717void TabContents::OnCrashedWorker() {
1718 AddInfoBar(new SimpleAlertInfoBarDelegate(
1719 this, l10n_util::GetString(IDS_WEBWORKER_CRASHED_PROMPT),
1720 NULL));
1721}
1722
1723void TabContents::OnDidGetApplicationInfo(
1724 int32 page_id,
1725 const webkit_glue::WebApplicationInfo& info) {
[email protected]ed5431872009-11-17 08:39:511726 web_app_info_ = info;
[email protected]bf5c2ff392009-07-08 16:24:331727
[email protected]ed5431872009-11-17 08:39:511728 if (delegate())
1729 delegate()->OnDidGetApplicationInfo(this, page_id);
[email protected]bf5c2ff392009-07-08 16:24:331730}
1731
1732void TabContents::DidStartProvisionalLoadForFrame(
1733 RenderViewHost* render_view_host,
1734 bool is_main_frame,
1735 const GURL& url) {
1736 ProvisionalLoadDetails details(is_main_frame,
1737 controller_.IsURLInPageNavigation(url),
1738 url, std::string(), false);
1739 NotificationService::current()->Notify(
1740 NotificationType::FRAME_PROVISIONAL_LOAD_START,
1741 Source<NavigationController>(&controller_),
1742 Details<ProvisionalLoadDetails>(&details));
1743}
1744
1745void TabContents::DidStartReceivingResourceResponse(
1746 ResourceRequestDetails* details) {
1747 NotificationService::current()->Notify(
1748 NotificationType::RESOURCE_RESPONSE_STARTED,
1749 Source<NavigationController>(&controller()),
1750 Details<ResourceRequestDetails>(details));
1751}
1752
1753void TabContents::DidRedirectResource(ResourceRequestDetails* details) {
1754 NotificationService::current()->Notify(
1755 NotificationType::RESOURCE_RECEIVED_REDIRECT,
1756 Source<NavigationController>(&controller()),
1757 Details<ResourceRequestDetails>(details));
1758}
1759
1760void TabContents::DidLoadResourceFromMemoryCache(
1761 const GURL& url,
1762 const std::string& frame_origin,
1763 const std::string& main_frame_origin,
1764 const std::string& security_info) {
1765 // Send out a notification that we loaded a resource from our memory cache.
1766 int cert_id = 0, cert_status = 0, security_bits = 0;
1767 SSLManager::DeserializeSecurityInfo(security_info,
1768 &cert_id, &cert_status,
1769 &security_bits);
1770 LoadFromMemoryCacheDetails details(url, frame_origin, main_frame_origin,
[email protected]76543b92009-08-31 17:27:451771 process()->id(), cert_id, cert_status);
[email protected]bf5c2ff392009-07-08 16:24:331772
1773 NotificationService::current()->Notify(
1774 NotificationType::LOAD_FROM_MEMORY_CACHE,
1775 Source<NavigationController>(&controller_),
1776 Details<LoadFromMemoryCacheDetails>(&details));
1777}
1778
[email protected]e3d60e5d2009-09-25 21:08:291779void TabContents::DidDisplayInsecureContent() {
[email protected]09843b5f2009-09-26 08:30:591780 controller_.ssl_manager()->DidDisplayInsecureContent();
[email protected]e3d60e5d2009-09-25 21:08:291781}
1782
1783void TabContents::DidRunInsecureContent(const std::string& security_origin) {
[email protected]09843b5f2009-09-26 08:30:591784 controller_.ssl_manager()->DidRunInsecureContent(security_origin);
[email protected]e3d60e5d2009-09-25 21:08:291785}
1786
[email protected]bf5c2ff392009-07-08 16:24:331787void TabContents::DidFailProvisionalLoadWithError(
1788 RenderViewHost* render_view_host,
1789 bool is_main_frame,
1790 int error_code,
1791 const GURL& url,
1792 bool showing_repost_interstitial) {
1793 if (net::ERR_ABORTED == error_code) {
1794 // EVIL HACK ALERT! Ignore failed loads when we're showing interstitials.
1795 // This means that the interstitial won't be torn down properly, which is
1796 // bad. But if we have an interstitial, go back to another tab type, and
1797 // then load the same interstitial again, we could end up getting the first
1798 // interstitial's "failed" message (as a result of the cancel) when we're on
1799 // the second one.
1800 //
1801 // We can't tell this apart, so we think we're tearing down the current page
1802 // which will cause a crash later one. There is also some code in
1803 // RenderViewHostManager::RendererAbortedProvisionalLoad that is commented
1804 // out because of this problem.
1805 //
1806 // http://code.google.com/p/chromium/issues/detail?id=2855
1807 // Because this will not tear down the interstitial properly, if "back" is
1808 // back to another tab type, the interstitial will still be somewhat alive
1809 // in the previous tab type. If you navigate somewhere that activates the
1810 // tab with the interstitial again, you'll see a flash before the new load
1811 // commits of the interstitial page.
1812 if (showing_interstitial_page()) {
1813 LOG(WARNING) << "Discarding message during interstitial.";
1814 return;
1815 }
1816
1817 // This will discard our pending entry if we cancelled the load (e.g., if we
1818 // decided to download the file instead of load it). Only discard the
1819 // pending entry if the URLs match, otherwise the user initiated a navigate
1820 // before the page loaded so that the discard would discard the wrong entry.
1821 NavigationEntry* pending_entry = controller_.pending_entry();
1822 if (pending_entry && pending_entry->url() == url) {
1823 controller_.DiscardNonCommittedEntries();
1824 // Update the URL display.
1825 NotifyNavigationStateChanged(TabContents::INVALIDATE_URL);
1826 }
1827
1828 render_manager_.RendererAbortedProvisionalLoad(render_view_host);
1829 }
1830
1831 // Send out a notification that we failed a provisional load with an error.
1832 ProvisionalLoadDetails details(is_main_frame,
1833 controller_.IsURLInPageNavigation(url),
1834 url, std::string(), false);
1835 details.set_error_code(error_code);
1836
1837 NotificationService::current()->Notify(
1838 NotificationType::FAIL_PROVISIONAL_LOAD_WITH_ERROR,
1839 Source<NavigationController>(&controller_),
1840 Details<ProvisionalLoadDetails>(&details));
1841}
1842
1843void TabContents::DocumentLoadedInFrame() {
1844 controller_.DocumentLoadedInFrame();
1845}
1846
[email protected]8d3347f2009-07-09 22:00:211847RenderViewHostDelegate::View* TabContents::GetViewDelegate() {
[email protected]420ae012009-04-24 05:16:321848 return view_.get();
1849}
1850
[email protected]8d3347f2009-07-09 22:00:211851RenderViewHostDelegate::RendererManagement*
1852TabContents::GetRendererManagementDelegate() {
1853 return &render_manager_;
1854}
1855
[email protected]bf5c2ff392009-07-08 16:24:331856RenderViewHostDelegate::BrowserIntegration*
[email protected]8d3347f2009-07-09 22:00:211857 TabContents::GetBrowserIntegrationDelegate() {
1858 return this;
[email protected]bf5c2ff392009-07-08 16:24:331859}
1860
[email protected]8d3347f2009-07-09 22:00:211861RenderViewHostDelegate::Resource* TabContents::GetResourceDelegate() {
1862 return this;
[email protected]bf5c2ff392009-07-08 16:24:331863}
1864
[email protected]8d3347f2009-07-09 22:00:211865RenderViewHostDelegate::Save* TabContents::GetSaveDelegate() {
[email protected]420ae012009-04-24 05:16:321866 return save_package_.get(); // May be NULL, but we can return NULL.
1867}
1868
[email protected]8d3347f2009-07-09 22:00:211869RenderViewHostDelegate::Printing* TabContents::GetPrintingDelegate() {
1870 return &printing_;
1871}
1872
1873RenderViewHostDelegate::FavIcon* TabContents::GetFavIconDelegate() {
1874 return &fav_icon_helper_;
1875}
1876
[email protected]c54d269e2009-10-21 18:07:381877RenderViewHostDelegate::FormFieldHistory*
1878TabContents::GetFormFieldHistoryDelegate() {
[email protected]19289d02009-10-21 21:47:001879 if (form_field_history_manager_.get() == NULL)
1880 form_field_history_manager_.reset(new FormFieldHistoryManager(this));
1881 return form_field_history_manager_.get();
[email protected]bf5c2ff392009-07-08 16:24:331882}
1883
[email protected]21674df2009-10-28 19:51:211884RenderViewHostDelegate::AutoFill* TabContents::GetAutoFillDelegate() {
1885 if (autofill_manager_.get() == NULL)
1886 autofill_manager_.reset(new AutoFillManager(this));
1887 return autofill_manager_.get();
1888}
1889
[email protected]93623c5d2009-12-10 21:40:321890RendererPreferences TabContents::GetRendererPrefs(Profile* profile) const {
[email protected]840b1512009-07-21 16:53:461891 return renderer_preferences_;
[email protected]80d96fa2009-06-10 22:34:511892}
1893
[email protected]57c6a652009-05-04 07:58:341894TabContents* TabContents::GetAsTabContents() {
1895 return this;
1896}
1897
[email protected]3e7cf1362009-08-21 17:47:081898void TabContents::AddBlockedNotice(const GURL& url, const string16& reason) {
1899 CreateBlockedPopupContainerIfNecessary();
1900 blocked_popups_->AddBlockedNotice(url, reason);
1901}
1902
[email protected]7b291f92009-08-14 05:43:531903ViewType::Type TabContents::GetRenderViewType() const {
1904 return ViewType::TAB_CONTENTS;
1905}
1906
1907int TabContents::GetBrowserWindowID() const {
1908 return controller().window_id().id();
1909}
1910
[email protected]420ae012009-04-24 05:16:321911void TabContents::RenderViewCreated(RenderViewHost* render_view_host) {
[email protected]2e4633c2009-07-09 16:58:061912 NotificationService::current()->Notify(
1913 NotificationType::RENDER_VIEW_HOST_CREATED_FOR_TAB,
1914 Source<TabContents>(this),
1915 Details<RenderViewHost>(render_view_host));
[email protected]420ae012009-04-24 05:16:321916 NavigationEntry* entry = controller_.GetActiveEntry();
1917 if (!entry)
1918 return;
1919
1920 // When we're creating views, we're still doing initial setup, so we always
1921 // use the pending DOM UI rather than any possibly existing committed one.
1922 if (render_manager_.pending_dom_ui()) {
1923 render_manager_.pending_dom_ui()->RenderViewCreated(render_view_host);
1924 }
1925
1926 if (entry->IsViewSourceMode()) {
1927 // Put the renderer in view source mode.
1928 render_view_host->Send(
1929 new ViewMsg_EnableViewSourceMode(render_view_host->routing_id()));
1930 }
[email protected]0666aef2009-05-13 19:48:081931
1932 view()->RenderViewCreated(render_view_host);
[email protected]420ae012009-04-24 05:16:321933}
1934
1935void TabContents::RenderViewReady(RenderViewHost* rvh) {
1936 if (rvh != render_view_host()) {
1937 // Don't notify the world, since this came from a renderer in the
1938 // background.
1939 return;
1940 }
1941
1942 NotifyConnected();
[email protected]9d8a4642009-07-29 17:25:301943 bool was_crashed = is_crashed();
[email protected]420ae012009-04-24 05:16:321944 SetIsCrashed(false);
[email protected]9d8a4642009-07-29 17:25:301945
1946 // Restore the focus to the tab (otherwise the focus will be on the top
1947 // window).
1948 if (was_crashed && !FocusLocationBarByDefault())
1949 Focus();
[email protected]420ae012009-04-24 05:16:321950}
1951
1952void TabContents::RenderViewGone(RenderViewHost* rvh) {
1953 // Ask the print preview if this renderer was valuable.
1954 if (!printing_.OnRenderViewGone(rvh))
1955 return;
1956 if (rvh != render_view_host()) {
1957 // The pending page's RenderViewHost is gone.
1958 return;
1959 }
1960
1961 SetIsLoading(false, NULL);
1962 NotifyDisconnected();
1963 SetIsCrashed(true);
1964
[email protected]8e537302009-06-10 21:19:581965 // Tell the view that we've crashed so it can prepare the sad tab page.
1966 view_->OnTabCrashed();
[email protected]420ae012009-04-24 05:16:321967
1968 // Hide any visible hung renderer warning for this web contents' process.
[email protected]e7b8d832009-11-20 22:41:001969 hung_renderer_dialog::HideForTabContents(this);
[email protected]420ae012009-04-24 05:16:321970}
1971
[email protected]2e4633c2009-07-09 16:58:061972void TabContents::RenderViewDeleted(RenderViewHost* rvh) {
1973 NotificationService::current()->Notify(
1974 NotificationType::RENDER_VIEW_HOST_DELETED,
1975 Source<TabContents>(this),
1976 Details<RenderViewHost>(rvh));
[email protected]fb7b79f72009-11-06 18:00:481977 render_manager_.RenderViewDeleted(rvh);
[email protected]2e4633c2009-07-09 16:58:061978}
1979
[email protected]420ae012009-04-24 05:16:321980void TabContents::DidNavigate(RenderViewHost* rvh,
1981 const ViewHostMsg_FrameNavigate_Params& params) {
[email protected]8030f012009-09-25 18:09:371982 int extra_invalidate_flags = 0;
1983
1984 if (PageTransition::IsMainFrame(params.transition)) {
[email protected]20ede072009-10-06 00:28:351985 bool was_bookmark_bar_visible = ShouldShowBookmarkBar();
[email protected]8030f012009-09-25 18:09:371986 bool was_extension_shelf_visible = IsExtensionShelfAlwaysVisible();
1987
[email protected]420ae012009-04-24 05:16:321988 render_manager_.DidNavigateMainFrame(rvh);
1989
[email protected]20ede072009-10-06 00:28:351990 if (was_bookmark_bar_visible != ShouldShowBookmarkBar())
[email protected]8030f012009-09-25 18:09:371991 extra_invalidate_flags |= INVALIDATE_BOOKMARK_BAR;
1992 if (was_extension_shelf_visible != IsExtensionShelfAlwaysVisible())
1993 extra_invalidate_flags |= INVALIDATE_EXTENSION_SHELF;
1994 }
1995
[email protected]420ae012009-04-24 05:16:321996 // Update the site of the SiteInstance if it doesn't have one yet.
1997 if (!GetSiteInstance()->has_site())
1998 GetSiteInstance()->SetSite(params.url);
1999
2000 // Need to update MIME type here because it's referred to in
2001 // UpdateNavigationCommands() called by RendererDidNavigate() to
2002 // determine whether or not to enable the encoding menu.
2003 // It's updated only for the main frame. For a subframe,
2004 // RenderView::UpdateURL does not set params.contents_mime_type.
2005 // (see http://code.google.com/p/chromium/issues/detail?id=2929 )
2006 // TODO(jungshik): Add a test for the encoding menu to avoid
2007 // regressing it again.
2008 if (PageTransition::IsMainFrame(params.transition))
2009 contents_mime_type_ = params.contents_mime_type;
2010
2011 NavigationController::LoadCommittedDetails details;
[email protected]8030f012009-09-25 18:09:372012 bool did_navigate = controller_.RendererDidNavigate(
2013 params, extra_invalidate_flags, &details);
[email protected]3e90d4a2009-07-03 17:38:392014
2015 // Update history. Note that this needs to happen after the entry is complete,
2016 // which WillNavigate[Main,Sub]Frame will do before this function is called.
[email protected]2e29d922009-10-22 22:13:352017 if (params.should_update_history &&
2018 (!delegate() || delegate()->ShouldAddNavigationsToHistory())) {
[email protected]3e90d4a2009-07-03 17:38:392019 // Most of the time, the displayURL matches the loaded URL, but for about:
2020 // URLs, we use a data: URL as the real value. We actually want to save
2021 // the about: URL to the history db and keep the data: URL hidden. This is
2022 // what the TabContents' URL getter does.
2023 UpdateHistoryForNavigation(GetURL(), details, params);
2024 }
2025
[email protected]76543b92009-08-31 17:27:452026 if (!did_navigate)
2027 return; // No navigation happened.
[email protected]420ae012009-04-24 05:16:322028
2029 // DO NOT ADD MORE STUFF TO THIS FUNCTION! Your component should either listen
2030 // for the appropriate notification (best) or you can add it to
2031 // DidNavigateMainFramePostCommit / DidNavigateAnyFramePostCommit (only if
2032 // necessary, please).
2033
2034 // Run post-commit tasks.
2035 if (details.is_main_frame)
2036 DidNavigateMainFramePostCommit(details, params);
2037 DidNavigateAnyFramePostCommit(rvh, details, params);
2038}
2039
2040void TabContents::UpdateState(RenderViewHost* rvh,
2041 int32 page_id,
2042 const std::string& state) {
2043 DCHECK(rvh == render_view_host());
2044
2045 // We must be prepared to handle state updates for any page, these occur
2046 // when the user is scrolling and entering form data, as well as when we're
2047 // leaving a page, in which case our state may have already been moved to
2048 // the next page. The navigation controller will look up the appropriate
2049 // NavigationEntry and update it when it is notified via the delegate.
2050
2051 int entry_index = controller_.GetEntryIndexWithPageID(
2052 GetSiteInstance(), page_id);
2053 if (entry_index < 0)
2054 return;
2055 NavigationEntry* entry = controller_.GetEntryAtIndex(entry_index);
2056
2057 if (state == entry->content_state())
2058 return; // Nothing to update.
2059 entry->set_content_state(state);
2060 controller_.NotifyEntryChanged(entry, entry_index);
2061}
2062
2063void TabContents::UpdateTitle(RenderViewHost* rvh,
2064 int32 page_id, const std::wstring& title) {
2065 // If we have a title, that's a pretty good indication that we've started
2066 // getting useful data.
2067 SetNotWaitingForResponse();
2068
2069 DCHECK(rvh == render_view_host());
2070 NavigationEntry* entry = controller_.GetEntryWithPageID(GetSiteInstance(),
2071 page_id);
2072 if (!entry || !UpdateTitleForEntry(entry, title))
2073 return;
2074
2075 // Broadcast notifications when the UI should be updated.
2076 if (entry == controller_.GetEntryAtOffset(0))
[email protected]f1cd5e82009-10-23 17:19:032077 NotifyNavigationStateChanged(INVALIDATE_TITLE);
[email protected]420ae012009-04-24 05:16:322078}
2079
[email protected]420ae012009-04-24 05:16:322080void TabContents::UpdateEncoding(RenderViewHost* render_view_host,
[email protected]41fc0322009-09-04 22:23:402081 const std::string& encoding) {
[email protected]420ae012009-04-24 05:16:322082 set_encoding(encoding);
2083}
2084
2085void TabContents::UpdateTargetURL(int32 page_id, const GURL& url) {
2086 if (delegate())
2087 delegate()->UpdateTargetURL(this, url);
2088}
2089
2090void TabContents::UpdateThumbnail(const GURL& url,
2091 const SkBitmap& bitmap,
2092 const ThumbnailScore& score) {
2093 // Tell History about this thumbnail
[email protected]449478302009-06-09 20:04:282094 if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kThumbnailStore)) {
[email protected]72d0fc72009-07-09 17:30:492095 if (!profile()->IsOffTheRecord())
[email protected]42339402009-07-17 17:27:192096 profile()->GetThumbnailStore()->SetPageThumbnail(url, bitmap,
2097 score, true);
[email protected]449478302009-06-09 20:04:282098 } else {
2099 HistoryService* hs;
2100 if (!profile()->IsOffTheRecord() &&
2101 (hs = profile()->GetHistoryService(Profile::IMPLICIT_ACCESS))) {
2102 hs->SetPageThumbnail(url, bitmap, score);
2103 }
[email protected]420ae012009-04-24 05:16:322104 }
2105}
2106
[email protected]8922e1f2009-10-03 05:01:262107void TabContents::UpdateInspectorSettings(const std::string& raw_settings) {
[email protected]0df30122009-06-03 12:13:082108 profile()->GetPrefs()->SetString(prefs::kWebKitInspectorSettings,
[email protected]8922e1f2009-10-03 05:01:262109 UTF8ToWide(raw_settings));
[email protected]0df30122009-06-03 12:13:082110}
2111
[email protected]420ae012009-04-24 05:16:322112void TabContents::Close(RenderViewHost* rvh) {
[email protected]07707302009-11-06 00:50:292113 // The UI may be in an event-tracking loop, such as between the
2114 // mouse-down and mouse-up in text selection or a button click.
2115 // Defer the close until after tracking is complete, so that we
2116 // don't free objects out from under the UI.
2117 // TODO(shess): This could probably be integrated with the
2118 // IsDoingDrag() test below. Punting for now because I need more
2119 // research to understand how this impacts platforms other than Mac.
2120 // TODO(shess): This could get more fine-grained. For instance,
2121 // closing a tab in another window while selecting text in the
2122 // current window's Omnibox should be just fine.
2123 if (view()->IsEventTracking()) {
2124 view()->CloseTabAfterEventTracking();
2125 return;
2126 }
2127
[email protected]24a4d1062009-07-10 23:10:422128 // If we close the tab while we're in the middle of a drag, we'll crash.
2129 // Instead, cancel the drag and close it as soon as the drag ends.
2130 if (view()->IsDoingDrag()) {
2131 view()->CancelDragAndCloseTab();
2132 return;
2133 }
2134
[email protected]420ae012009-04-24 05:16:322135 // Ignore this if it comes from a RenderViewHost that we aren't showing.
2136 if (delegate() && rvh == render_view_host())
2137 delegate()->CloseContents(this);
2138}
2139
2140void TabContents::RequestMove(const gfx::Rect& new_bounds) {
2141 if (delegate() && delegate()->IsPopup(this))
2142 delegate()->MoveContents(this, new_bounds);
2143}
2144
[email protected]7ab1e7d62009-10-14 23:32:012145void TabContents::DidStartLoading() {
[email protected]420ae012009-04-24 05:16:322146 SetIsLoading(true, NULL);
2147}
2148
[email protected]7ab1e7d62009-10-14 23:32:012149void TabContents::DidStopLoading() {
[email protected]420ae012009-04-24 05:16:322150 scoped_ptr<LoadNotificationDetails> details;
2151
2152 NavigationEntry* entry = controller_.GetActiveEntry();
2153 // An entry may not exist for a stop when loading an initial blank page or
2154 // if an iframe injected by script into a blank page finishes loading.
2155 if (entry) {
[email protected]420ae012009-04-24 05:16:322156 base::TimeDelta elapsed = base::TimeTicks::Now() - current_load_start_;
2157
2158 details.reset(new LoadNotificationDetails(
[email protected]ebe89e062009-08-13 23:16:542159 entry->virtual_url(),
[email protected]420ae012009-04-24 05:16:322160 entry->transition_type(),
2161 elapsed,
2162 &controller_,
2163 controller_.GetCurrentEntryIndex()));
2164 }
2165
2166 // Tell PasswordManager we've finished a page load, which serves as a
2167 // green light to save pending passwords and reset itself.
2168 GetPasswordManager()->DidStopLoading();
2169
2170 SetIsLoading(false, details.get());
2171}
2172
[email protected]420ae012009-04-24 05:16:322173void TabContents::DidRedirectProvisionalLoad(int32 page_id,
2174 const GURL& source_url,
2175 const GURL& target_url) {
2176 NavigationEntry* entry;
2177 if (page_id == -1)
2178 entry = controller_.pending_entry();
2179 else
2180 entry = controller_.GetEntryWithPageID(GetSiteInstance(), page_id);
2181 if (!entry || entry->url() != source_url)
2182 return;
2183 entry->set_url(target_url);
2184}
2185
[email protected]420ae012009-04-24 05:16:322186void TabContents::RequestOpenURL(const GURL& url, const GURL& referrer,
2187 WindowOpenDisposition disposition) {
2188 if (render_manager_.dom_ui()) {
2189 // When we're a DOM UI, it will provide a page transition type for us (this
2190 // is so the new tab page can specify AUTO_BOOKMARK for automatically
2191 // generated suggestions).
2192 //
2193 // Note also that we hide the referrer for DOM UI pages. We don't really
[email protected]60e448982009-05-06 04:21:162194 // want web sites to see a referrer of "chrome://blah" (and some
2195 // chrome: URLs might have search terms or other stuff we don't want to
[email protected]420ae012009-04-24 05:16:322196 // send to the site), so we send no referrer.
2197 OpenURL(url, GURL(), disposition,
2198 render_manager_.dom_ui()->link_transition_type());
2199 } else {
2200 OpenURL(url, referrer, disposition, PageTransition::LINK);
2201 }
2202}
2203
[email protected]1ee614862009-07-06 20:29:182204void TabContents::DomOperationResponse(const std::string& json_string,
2205 int automation_id) {
2206}
2207
[email protected]420ae012009-04-24 05:16:322208void TabContents::ProcessDOMUIMessage(const std::string& message,
[email protected]e4dad9fb2009-10-06 18:15:582209 const Value* content,
[email protected]811bfe32009-07-01 08:46:252210 int request_id,
2211 bool has_callback) {
[email protected]420ae012009-04-24 05:16:322212 if (!render_manager_.dom_ui()) {
[email protected]c2e74fe82009-09-03 17:57:442213 // This can happen if someone uses window.open() to open an extension URL
2214 // from a non-extension context.
2215 render_view_host()->BlockExtensionRequest(request_id);
[email protected]420ae012009-04-24 05:16:322216 return;
2217 }
[email protected]811bfe32009-07-01 08:46:252218 render_manager_.dom_ui()->ProcessDOMUIMessage(message, content, request_id,
2219 has_callback);
[email protected]420ae012009-04-24 05:16:322220}
2221
2222void TabContents::ProcessExternalHostMessage(const std::string& message,
2223 const std::string& origin,
2224 const std::string& target) {
2225 if (delegate())
2226 delegate()->ForwardMessageToExternalHost(message, origin, target);
2227}
2228
[email protected]420ae012009-04-24 05:16:322229void TabContents::RunFileChooser(bool multiple_files,
2230 const string16& title,
2231 const FilePath& default_file) {
2232 if (!select_file_dialog_.get())
2233 select_file_dialog_ = SelectFileDialog::Create(this);
2234 SelectFileDialog::Type dialog_type =
2235 multiple_files ? SelectFileDialog::SELECT_OPEN_MULTI_FILE :
2236 SelectFileDialog::SELECT_OPEN_FILE;
2237 select_file_dialog_->SelectFile(dialog_type, title, default_file,
2238 NULL, 0, FILE_PATH_LITERAL(""),
2239 view_->GetTopLevelNativeWindow(), NULL);
2240}
2241
2242void TabContents::RunJavaScriptMessage(
2243 const std::wstring& message,
2244 const std::wstring& default_prompt,
2245 const GURL& frame_url,
2246 const int flags,
2247 IPC::Message* reply_msg,
2248 bool* did_suppress_message) {
2249 // Suppress javascript messages when requested and when inside a constrained
2250 // popup window (because that activates them and breaks them out of the
2251 // constrained window jail).
[email protected]91ed49a2009-07-07 21:29:552252 // Also suppress messages when showing an interstitial. The interstitial is
2253 // shown over the previous page, we don't want the hidden page dialogs to
2254 // interfere with the interstitial.
2255 bool suppress_this_message = suppress_javascript_messages_ ||
2256 showing_interstitial_page();
[email protected]420ae012009-04-24 05:16:322257 if (delegate())
2258 suppress_this_message |=
[email protected]b6c874582009-05-08 19:38:312259 (delegate()->GetConstrainingContents(this) != this);
[email protected]420ae012009-04-24 05:16:322260
2261 *did_suppress_message = suppress_this_message;
2262
2263 if (!suppress_this_message) {
2264 base::TimeDelta time_since_last_message(
2265 base::TimeTicks::Now() - last_javascript_message_dismissal_);
2266 bool show_suppress_checkbox = false;
2267 // Show a checkbox offering to suppress further messages if this message is
2268 // being displayed within kJavascriptMessageExpectedDelay of the last one.
2269 if (time_since_last_message <
2270 base::TimeDelta::FromMilliseconds(kJavascriptMessageExpectedDelay))
2271 show_suppress_checkbox = true;
2272
[email protected]d82ed61e2009-06-16 02:46:222273 RunJavascriptMessageBox(this, frame_url, flags, message, default_prompt,
[email protected]420ae012009-04-24 05:16:322274 show_suppress_checkbox, reply_msg);
2275 } else {
2276 // If we are suppressing messages, just reply as is if the user immediately
2277 // pressed "Cancel".
[email protected]beb440c2009-11-06 04:08:542278 OnMessageBoxClosed(reply_msg, false, std::wstring());
[email protected]420ae012009-04-24 05:16:322279 }
2280}
2281
2282void TabContents::RunBeforeUnloadConfirm(const std::wstring& message,
2283 IPC::Message* reply_msg) {
[email protected]7ab1e7d62009-10-14 23:32:012284 is_showing_before_unload_dialog_ = true;
[email protected]d82ed61e2009-06-16 02:46:222285 RunBeforeUnloadDialog(this, message, reply_msg);
[email protected]420ae012009-04-24 05:16:322286}
2287
2288void TabContents::ShowModalHTMLDialog(const GURL& url, int width, int height,
2289 const std::string& json_arguments,
2290 IPC::Message* reply_msg) {
2291 if (delegate()) {
2292 HtmlDialogUIDelegate* dialog_delegate =
2293 new ModalHtmlDialogDelegate(url, width, height, json_arguments,
[email protected]d82ed61e2009-06-16 02:46:222294 reply_msg, this);
[email protected]420ae012009-04-24 05:16:322295 delegate()->ShowHtmlDialog(dialog_delegate, NULL);
2296 }
2297}
2298
2299void TabContents::PasswordFormsSeen(
[email protected]ed3fb032009-06-16 19:50:562300 const std::vector<webkit_glue::PasswordForm>& forms) {
[email protected]420ae012009-04-24 05:16:322301 GetPasswordManager()->PasswordFormsSeen(forms);
2302}
2303
[email protected]420ae012009-04-24 05:16:322304// Checks to see if we should generate a keyword based on the OSDD, and if
2305// necessary uses TemplateURLFetcher to download the OSDD and create a keyword.
2306void TabContents::PageHasOSDD(RenderViewHost* render_view_host,
2307 int32 page_id, const GURL& url,
2308 bool autodetected) {
2309 // Make sure page_id is the current page, and the TemplateURLModel is loaded.
2310 DCHECK(url.is_valid());
2311 if (!IsActiveEntry(page_id))
2312 return;
2313 TemplateURLModel* url_model = profile()->GetTemplateURLModel();
2314 if (!url_model)
2315 return;
2316 if (!url_model->loaded()) {
2317 url_model->Load();
2318 return;
2319 }
2320 if (!profile()->GetTemplateURLFetcher())
2321 return;
2322
2323 if (profile()->IsOffTheRecord())
2324 return;
2325
2326 const NavigationEntry* entry = controller_.GetLastCommittedEntry();
2327 DCHECK(entry);
2328
2329 const NavigationEntry* base_entry = entry;
2330 if (IsFormSubmit(base_entry)) {
2331 // If the current page is a form submit, find the last page that was not
2332 // a form submit and use its url to generate the keyword from.
2333 int index = controller_.last_committed_entry_index() - 1;
2334 while (index >= 0 && IsFormSubmit(controller_.GetEntryAtIndex(index)))
2335 index--;
2336 if (index >= 0)
2337 base_entry = controller_.GetEntryAtIndex(index);
2338 else
2339 base_entry = NULL;
2340 }
2341
2342 // We want to use the user typed URL if available since that represents what
2343 // the user typed to get here, and fall back on the regular URL if not.
2344 if (!base_entry)
2345 return;
2346 GURL keyword_url = base_entry->user_typed_url().is_valid() ?
2347 base_entry->user_typed_url() : base_entry->url();
2348 if (!keyword_url.is_valid())
2349 return;
2350 std::wstring keyword = TemplateURLModel::GenerateKeyword(keyword_url,
2351 autodetected);
2352 if (keyword.empty())
2353 return;
2354 const TemplateURL* template_url =
2355 url_model->GetTemplateURLForKeyword(keyword);
2356 if (template_url && (!template_url->safe_for_autoreplace() ||
2357 template_url->originating_url() == url)) {
2358 // Either there is a user created TemplateURL for this keyword, or the
2359 // keyword has the same OSDD url and we've parsed it.
2360 return;
2361 }
2362
2363 // Download the OpenSearch description document. If this is successful a
2364 // new keyword will be created when done.
[email protected]420ae012009-04-24 05:16:322365 profile()->GetTemplateURLFetcher()->ScheduleDownload(
2366 keyword,
2367 url,
2368 base_entry->favicon().url(),
[email protected]d0cc9fb52009-06-23 02:26:162369 this,
[email protected]420ae012009-04-24 05:16:322370 autodetected);
2371}
2372
[email protected]420ae012009-04-24 05:16:322373GURL TabContents::GetAlternateErrorPageURL() const {
2374 GURL url;
2375 // Disable alternate error pages when in OffTheRecord/Incognito mode.
2376 if (profile()->IsOffTheRecord())
2377 return url;
2378
2379 PrefService* prefs = profile()->GetPrefs();
2380 DCHECK(prefs);
2381 if (prefs->GetBoolean(prefs::kAlternateErrorPagesEnabled)) {
[email protected]a33457b82009-09-21 23:07:152382 url = google_util::AppendGoogleLocaleParam(
2383 GURL(google_util::kLinkDoctorBaseURL));
[email protected]420ae012009-04-24 05:16:322384 url = google_util::AppendGoogleTLDParam(url);
2385 }
2386 return url;
2387}
2388
2389WebPreferences TabContents::GetWebkitPrefs() {
2390 PrefService* prefs = render_view_host()->process()->profile()->GetPrefs();
[email protected]7ccddb8c2009-08-04 17:36:552391 bool is_dom_ui = false;
2392 return RenderViewHostDelegateHelper::GetWebkitPrefs(prefs, is_dom_ui);
[email protected]420ae012009-04-24 05:16:322393}
2394
[email protected]420ae012009-04-24 05:16:322395void TabContents::OnJSOutOfMemory() {
2396 AddInfoBar(new SimpleAlertInfoBarDelegate(
2397 this, l10n_util::GetString(IDS_JS_OUT_OF_MEMORY_PROMPT), NULL));
2398}
2399
[email protected]420ae012009-04-24 05:16:322400void TabContents::OnCrossSiteResponse(int new_render_process_host_id,
2401 int new_request_id) {
[email protected]57c6a652009-05-04 07:58:342402 // Allows the TabContents to react when a cross-site response is ready to be
[email protected]420ae012009-04-24 05:16:322403 // delivered to a pending RenderViewHost. We must first run the onunload
2404 // handler of the old RenderViewHost before we can allow it to proceed.
2405 render_manager_.OnCrossSiteResponse(new_render_process_host_id,
2406 new_request_id);
2407}
2408
2409bool TabContents::CanBlur() const {
2410 return delegate() ? delegate()->CanBlur() : true;
2411}
2412
2413gfx::Rect TabContents::GetRootWindowResizerRect() const {
2414 if (delegate())
2415 return delegate()->GetRootWindowResizerRect();
2416 return gfx::Rect();
2417}
2418
2419void TabContents::RendererUnresponsive(RenderViewHost* rvh,
2420 bool is_during_unload) {
2421 if (is_during_unload) {
2422 // Hang occurred while firing the beforeunload/unload handler.
2423 // Pretend the handler fired so tab closing continues as if it had.
[email protected]829e7612009-04-25 01:15:112424 rvh->set_sudden_termination_allowed(true);
[email protected]420ae012009-04-24 05:16:322425
2426 if (!render_manager_.ShouldCloseTabOnUnresponsiveRenderer())
2427 return;
2428
2429 // If the tab hangs in the beforeunload/unload handler there's really
2430 // nothing we can do to recover. Pretend the unload listeners have
2431 // all fired and close the tab. If the hang is in the beforeunload handler
2432 // then the user will not have the option of cancelling the close.
2433 Close(rvh);
2434 return;
2435 }
2436
2437 if (render_view_host() && render_view_host()->IsRenderViewLive())
[email protected]e7b8d832009-11-20 22:41:002438 hung_renderer_dialog::ShowForTabContents(this);
[email protected]420ae012009-04-24 05:16:322439}
2440
2441void TabContents::RendererResponsive(RenderViewHost* render_view_host) {
[email protected]e7b8d832009-11-20 22:41:002442 hung_renderer_dialog::HideForTabContents(this);
[email protected]420ae012009-04-24 05:16:322443}
2444
2445void TabContents::LoadStateChanged(const GURL& url,
[email protected]094e5b22009-09-25 04:23:562446 net::LoadState load_state,
2447 uint64 upload_position,
2448 uint64 upload_size) {
[email protected]420ae012009-04-24 05:16:322449 load_state_ = load_state;
[email protected]094e5b22009-09-25 04:23:562450 upload_position_ = upload_position;
2451 upload_size_ = upload_size;
[email protected]d686e812009-06-03 19:10:292452 std::wstring languages =
2453 profile()->GetPrefs()->GetString(prefs::kAcceptLanguages);
[email protected]d686e812009-06-03 19:10:292454 std::string host = url.host();
[email protected]ce85f602009-11-07 01:34:532455 load_state_host_ =
2456 net::IDNToUnicode(host.c_str(), host.size(), languages, NULL);
[email protected]420ae012009-04-24 05:16:322457 if (load_state_ == net::LOAD_STATE_READING_RESPONSE)
2458 SetNotWaitingForResponse();
2459 if (is_loading())
[email protected]c9cd2222009-05-06 05:16:502460 NotifyNavigationStateChanged(INVALIDATE_LOAD | INVALIDATE_TAB);
[email protected]420ae012009-04-24 05:16:322461}
2462
[email protected]1ee614862009-07-06 20:29:182463bool TabContents::IsExternalTabContainer() const {
2464 if (!delegate())
2465 return false;
2466
2467 return delegate()->IsExternalTabContainer();
2468}
2469
[email protected]1ee614862009-07-06 20:29:182470void TabContents::DidInsertCSS() {
2471 // This RVHDelegate function is used for extensions and not us.
[email protected]420ae012009-04-24 05:16:322472}
2473
[email protected]130efb02009-09-18 18:54:352474void TabContents::FocusedNodeChanged() {
2475 NotificationService::current()->Notify(
2476 NotificationType::FOCUS_CHANGED_IN_PAGE,
2477 Source<RenderViewHost>(render_view_host()),
2478 NotificationService::NoDetails());
2479}
2480
[email protected]420ae012009-04-24 05:16:322481void TabContents::FileSelected(const FilePath& path,
2482 int index, void* params) {
2483 render_view_host()->FileSelected(path);
2484}
2485
2486void TabContents::MultiFilesSelected(const std::vector<FilePath>& files,
2487 void* params) {
2488 render_view_host()->MultiFilesSelected(files);
2489}
2490
2491void TabContents::FileSelectionCanceled(void* params) {
2492 // If the user cancels choosing a file to upload we pass back an
2493 // empty vector.
2494 render_view_host()->MultiFilesSelected(std::vector<FilePath>());
2495}
2496
2497void TabContents::BeforeUnloadFiredFromRenderManager(
2498 bool proceed,
2499 bool* proceed_to_fire_unload) {
2500 if (delegate())
2501 delegate()->BeforeUnloadFired(this, proceed, proceed_to_fire_unload);
2502}
2503
2504void TabContents::UpdateRenderViewSizeForRenderManager() {
2505 // TODO(brettw) this is a hack. See TabContentsView::SizeContents.
2506 view_->SizeContents(view_->GetContainerSize());
2507}
2508
2509DOMUI* TabContents::CreateDOMUIForRenderManager(const GURL& url) {
[email protected]d82ed61e2009-06-16 02:46:222510 return DOMUIFactory::CreateDOMUIForURL(this, url);
[email protected]420ae012009-04-24 05:16:322511}
2512
2513NavigationEntry*
2514TabContents::GetLastCommittedNavigationEntryForRenderManager() {
2515 return controller_.GetLastCommittedEntry();
2516}
2517
2518bool TabContents::CreateRenderViewForRenderManager(
2519 RenderViewHost* render_view_host) {
[email protected]811bfe32009-07-01 08:46:252520 // If the pending navigation is to a DOMUI, tell the RenderView about any
2521 // bindings it will need enabled.
[email protected]420ae012009-04-24 05:16:322522 if (render_manager_.pending_dom_ui())
[email protected]811bfe32009-07-01 08:46:252523 render_view_host->AllowBindings(
2524 render_manager_.pending_dom_ui()->bindings());
[email protected]1adff062009-06-02 18:39:552525
[email protected]420ae012009-04-24 05:16:322526 RenderWidgetHostView* rwh_view = view_->CreateViewForWidget(render_view_host);
[email protected]1a98a932009-11-17 00:12:522527
2528 scoped_refptr<URLRequestContextGetter> request_context = request_context_;
2529 if (!request_context.get())
2530 request_context = profile()->GetRequestContext();
2531
2532 if (!render_view_host->CreateRenderView(request_context))
[email protected]420ae012009-04-24 05:16:322533 return false;
2534
2535 // Now that the RenderView has been created, we need to tell it its size.
2536 rwh_view->SetSize(view_->GetContainerSize());
2537
2538 UpdateMaxPageIDIfNecessary(render_view_host->site_instance(),
2539 render_view_host);
2540 return true;
2541}
2542
2543void TabContents::Observe(NotificationType type,
2544 const NotificationSource& source,
2545 const NotificationDetails& details) {
2546 switch (type.value) {
2547 case NotificationType::BOOKMARK_MODEL_LOADED:
2548 // BookmarkModel finished loading, fall through to update starred state.
2549 case NotificationType::URLS_STARRED: {
2550 // Somewhere, a URL has been starred.
2551 // Ignore notifications for profiles other than our current one.
2552 Profile* source_profile = Source<Profile>(source).ptr();
2553 if (!source_profile || !source_profile->IsSameProfile(profile()))
2554 return;
2555
2556 UpdateStarredStateForCurrentURL();
2557 break;
2558 }
2559 case NotificationType::PREF_CHANGED: {
2560 std::wstring* pref_name_in = Details<std::wstring>(details).ptr();
2561 DCHECK(Source<PrefService>(source).ptr() == profile()->GetPrefs());
2562 if (*pref_name_in == prefs::kAlternateErrorPagesEnabled) {
2563 UpdateAlternateErrorPageURL();
2564 } else if (*pref_name_in == prefs::kDefaultCharset ||
2565 StartsWithASCII(WideToUTF8(*pref_name_in), "webkit.webprefs.", true)
2566 ) {
2567 UpdateWebPreferences();
2568 } else {
2569 NOTREACHED() << "unexpected pref change notification" << *pref_name_in;
2570 }
2571 break;
2572 }
2573 case NotificationType::RENDER_WIDGET_HOST_DESTROYED:
2574 view_->RenderWidgetHostDestroyed(Source<RenderWidgetHost>(source).ptr());
2575 break;
2576
2577 case NotificationType::NAV_ENTRY_COMMITTED: {
2578 DCHECK(&controller_ == Source<NavigationController>(source).ptr());
2579
2580 NavigationController::LoadCommittedDetails& committed_details =
2581 *(Details<NavigationController::LoadCommittedDetails>(details).ptr());
2582 ExpireInfoBars(committed_details);
2583 break;
2584 }
2585
[email protected]d3ba77272009-09-03 00:06:092586#if defined(OS_LINUX)
2587 case NotificationType::BROWSER_THEME_CHANGED: {
2588 render_view_host()->SyncRendererPrefs();
2589 break;
2590 }
2591#endif
2592
[email protected]420ae012009-04-24 05:16:322593 default:
2594 NOTREACHED();
2595 }
2596}
[email protected]aacd7cc2009-09-02 14:51:102597
[email protected]beb440c2009-11-06 04:08:542598std::wstring TabContents::GetMessageBoxTitle(const GURL& frame_url,
2599 bool is_alert) {
2600 if (!frame_url.has_host())
2601 return l10n_util::GetString(
2602 is_alert ? IDS_JAVASCRIPT_ALERT_DEFAULT_TITLE
2603 : IDS_JAVASCRIPT_MESSAGEBOX_DEFAULT_TITLE);
2604
2605 // We really only want the scheme, hostname, and port.
2606 GURL::Replacements replacements;
2607 replacements.ClearUsername();
2608 replacements.ClearPassword();
2609 replacements.ClearPath();
2610 replacements.ClearQuery();
2611 replacements.ClearRef();
2612 GURL clean_url = frame_url.ReplaceComponents(replacements);
2613
2614 // TODO(brettw) it should be easier than this to do the correct language
2615 // handling without getting the accept language from the profile.
2616 std::wstring base_address = gfx::ElideUrl(clean_url, gfx::Font(), 0,
2617 profile()->GetPrefs()->GetString(prefs::kAcceptLanguages));
2618 // Force URL to have LTR directionality.
2619 if (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT)
2620 l10n_util::WrapStringWithLTRFormatting(&base_address);
2621
2622 return l10n_util::GetStringF(
2623 is_alert ? IDS_JAVASCRIPT_ALERT_TITLE : IDS_JAVASCRIPT_MESSAGEBOX_TITLE,
2624 base_address);
2625}
2626
2627gfx::NativeWindow TabContents::GetMessageBoxRootWindow() {
2628 return view_->GetTopLevelNativeWindow();
2629}
2630
2631void TabContents::OnMessageBoxClosed(IPC::Message* reply_msg,
2632 bool success,
2633 const std::wstring& prompt) {
2634 last_javascript_message_dismissal_ = base::TimeTicks::Now();
2635 if (is_showing_before_unload_dialog_ && !success) {
2636 // If a beforeunload dialog is canceled, we need to stop the throbber from
2637 // spinning, since we forced it to start spinning in Navigate.
2638 DidStopLoading();
2639
2640 tab_close_start_time_ = base::TimeTicks();
2641 }
2642 is_showing_before_unload_dialog_ = false;
2643 render_view_host()->JavaScriptMessageBoxClosed(reply_msg, success, prompt);
2644}
2645
2646void TabContents::SetSuppressMessageBoxes(bool suppress_message_boxes) {
2647 set_suppress_javascript_messages(suppress_message_boxes);
2648}
2649
[email protected]41fc0322009-09-04 22:23:402650void TabContents::set_encoding(const std::string& encoding) {
[email protected]aacd7cc2009-09-02 14:51:102651 encoding_ = CharacterEncoding::GetCanonicalEncodingNameByAliasName(encoding);
2652}