Move a bunch of methods from TabContents into the WebContents interface. This change either moves...

content/browser/tab_contents/tab_contents.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/tab_contents/tab_contents.h"
 
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
@@ skipping 252 matching lines @@
     UMA_HISTOGRAM_TIMES("Tab.Close",
         base::TimeTicks::Now() - tab_close_start_time_);
   }
 
   FOR_EACH_OBSERVER(TabContentsObserver, observers_, TabContentsDestroyed());
 
   SetDelegate(NULL);
 }
 
 bool TabContents::OnMessageReceived(const IPC::Message& message) {
-  if (web_ui() && web_ui()->OnMessageReceived(message))
+  if (GetWebUI() && GetWebUI()->OnMessageReceived(message))
     return true;
 
   ObserverListBase<TabContentsObserver>::Iterator it(observers_);
   TabContentsObserver* observer;
   while ((observer = it.GetNext()) != NULL)
     if (observer->OnMessageReceived(message))
       return true;
 
   bool handled = true;
   bool message_is_ok = true;
@@ skipping 55 matching lines @@
 }
 
 content::BrowserContext* TabContents::GetBrowserContext() const {
   return controller_.browser_context();
 }
 
 void TabContents::SetViewType(content::ViewType type) {
   view_type_ = type;
 }
 
+const GURL& TabContents::GetURL() const {
+  // We may not have a navigation entry yet
+  NavigationEntry* entry = controller_.GetActiveEntry();
+  return entry ? entry->virtual_url() : GURL::EmptyGURL();
+}
+
+
+const base::PropertyBag* TabContents::GetPropertyBag() const {
+  return &property_bag_;
+}
+
+base::PropertyBag* TabContents::GetPropertyBag() {
+  return &property_bag_;
+}
+
+content::WebContentsDelegate* TabContents::GetDelegate() {
+  return delegate_;
+}
+
+void TabContents::SetDelegate(content::WebContentsDelegate* delegate) {
+  // TODO(cbentzel): remove this debugging code?
+  if (delegate == delegate_)
+    return;
+  if (delegate_)
+    delegate_->Detach(this);
+  delegate_ = delegate;
+  if (delegate_)
+    delegate_->Attach(this);
+}
+
 content::RenderProcessHost* TabContents::GetRenderProcessHost() const {
   if (render_manager_.current_host())
     return render_manager_.current_host()->process();
   else
     return NULL;
 }
 
-const GURL& TabContents::GetURL() const {
-  // We may not have a navigation entry yet
-  NavigationEntry* entry = controller_.GetActiveEntry();
-  return entry ? entry->virtual_url() : GURL::EmptyGURL();
+RenderViewHost* TabContents::GetRenderViewHost() const {
+  return render_manager_.current_host();
+}
+
+RenderWidgetHostView* TabContents::GetRenderWidgetHostView() const {
+  return render_manager_.GetRenderWidgetHostView();
+}
+
+TabContentsView* TabContents::GetView() const {
+  return view_.get();
+}
+
+WebUI* TabContents::GetWebUI() const {
+  return render_manager_.web_ui() ? render_manager_.web_ui()
+      : render_manager_.pending_web_ui();
+}
+
+WebUI* TabContents::GetCommittedWebUI() const {
+  return render_manager_.web_ui();
 }
 
 const string16& TabContents::GetTitle() const {
   // Transient entries take precedence. They are used for interstitial pages
   // that are shown on top of existing pages.
   NavigationEntry* entry = controller_.GetTransientEntry();
   std::string accept_languages =
       content::GetContentClient()->browser()->GetAcceptLangs(
           GetBrowserContext());
   if (entry) {
@@ skipping 51 matching lines @@
   return render_manager_.current_host()->site_instance();
 }
 
 SiteInstance* TabContents::GetPendingSiteInstance() const {
   RenderViewHost* dest_rvh = render_manager_.pending_render_view_host() ?
       render_manager_.pending_render_view_host() :
       render_manager_.current_host();
   return dest_rvh->site_instance();
 }
 
-void TabContents::AddObserver(TabContentsObserver* observer) {
-  observers_.AddObserver(observer);
+bool TabContents::IsLoading() const {
+  return is_loading_;
 }
 
-void TabContents::RemoveObserver(TabContentsObserver* observer) {
-  observers_.RemoveObserver(observer);
+bool TabContents::IsWaitingForResponse() const {
+  return waiting_for_response_;
+}
+
+const net::LoadStateWithParam& TabContents::GetLoadState() const {
+  return load_state_;
+}
+
+const string16& TabContents::GetLoadStateHost() const {
+  return load_state_host_;
+}
+
+uint64 TabContents::GetUploadSize() const {
+  return upload_size_;
+}
+
+uint64 TabContents::GetUploadPosition() const {
+  return upload_position_;
+}
+
+const std::string& TabContents::GetEncoding() const {
+  return encoding_;
+}
+
+bool TabContents::DisplayedInsecureContent() const {
+  return displayed_insecure_content_;
+}
+
+void TabContents::SetCapturingContents(bool cap) {
+  capturing_contents_ = cap;
+}
+
+bool TabContents::IsCrashed() const {
+  return (crashed_status_ == base::TERMINATION_STATUS_PROCESS_CRASHED ||
+          crashed_status_ == base::TERMINATION_STATUS_ABNORMAL_TERMINATION ||
+          crashed_status_ == base::TERMINATION_STATUS_PROCESS_WAS_KILLED);
 }
 
 void TabContents::SetIsCrashed(base::TerminationStatus status, int error_code) {
   if (status == crashed_status_)
     return;
 
   crashed_status_ = status;
   crashed_error_code_ = error_code;
   NotifyNavigationStateChanged(INVALIDATE_TAB);
 }
 
+base::TerminationStatus TabContents::GetCrashedStatus() const {
+  return crashed_status_;
+}
+
+bool TabContents::IsBeingDestroyed() const {
+  return is_being_destroyed_;
+}
+
 void TabContents::NotifyNavigationStateChanged(unsigned changed_flags) {
   if (delegate_)
     delegate_->NavigationStateChanged(this, changed_flags);
 }
 
 void TabContents::DidBecomeSelected() {
   controller_.SetActive(true);
   RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
   if (rwhv) {
     rwhv->DidBecomeSelected();
 #if defined(OS_MACOSX)
     rwhv->SetActive(true);
 #endif
   }
 
   last_selected_time_ = base::TimeTicks::Now();
 
   FOR_EACH_OBSERVER(TabContentsObserver, observers_, DidBecomeSelected());
 }
 
+
+base::TimeTicks TabContents::GetLastSelectedTime() const {
+  return last_selected_time_;
+}
+
 void TabContents::WasHidden() {
-  if (!capturing_contents()) {
+  if (!capturing_contents_) {
     // |GetRenderViewHost()| can be NULL if the user middle clicks a link to
     // open a tab in then background, then closes the tab before selecting it.
     // This is because closing the tab calls TabContents::Destroy(), which
     // removes the |GetRenderViewHost()|; then when we actually destroy the
     // window, OnWindowPosChanged() notices and calls HideContents() (which
     // calls us).
     RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
     if (rwhv)
       rwhv->WasHidden();
   }
 
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_CONTENTS_HIDDEN,
       content::Source<TabContents>(this),
       content::NotificationService::NoDetails());
 }
 
+void TabContents::ShowContents() {
+  RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
+  if (rwhv)
+    rwhv->DidBecomeSelected();
+}
+
+void TabContents::HideContents() {
+  // TODO(pkasting): http://b/1239839  Right now we purposefully don't call
+  // our superclass HideContents(), because some callers want to be very picky
+  // about the order in which these get called.  In addition to making the code
+  // here practically impossible to understand, this also means we end up
+  // calling TabContents::WasHidden() twice if callers call both versions of
+  // HideContents() on a TabContents.
+  WasHidden();
+}
+
+bool TabContents::NeedToFireBeforeUnload() {
+  // TODO(creis): Should we fire even for interstitial pages?
+  return notify_disconnection() &&
+      !showing_interstitial_page() &&
+      !GetRenderViewHost()->SuddenTerminationAllowed();
+}
+
+RenderViewHostManager* TabContents::GetRenderManagerForTesting() {
+  return &render_manager_;
+}
+
+void TabContents::AddObserver(TabContentsObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void TabContents::RemoveObserver(TabContentsObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 void TabContents::Activate() {
   if (delegate_)
     delegate_->ActivateContents(this);
 }
 
 void TabContents::Deactivate() {
   if (delegate_)
     delegate_->DeactivateContents(this);
 }
 
@@ skipping 56 matching lines @@
 }
 
 void TabContents::WebUISend(RenderViewHost* render_view_host,
                             const GURL& source_url,
                             const std::string& name,
                             const base::ListValue& args) {
   if (delegate_)
     delegate_->WebUISend(this, source_url, name, args);
 }
 
-void TabContents::ShowContents() {
-  RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
-  if (rwhv)
-    rwhv->DidBecomeSelected();
-}
-
-void TabContents::HideContents() {
-  // TODO(pkasting): http://b/1239839  Right now we purposefully don't call
-  // our superclass HideContents(), because some callers want to be very picky
-  // about the order in which these get called.  In addition to making the code
-  // here practically impossible to understand, this also means we end up
-  // calling TabContents::WasHidden() twice if callers call both versions of
-  // HideContents() on a TabContents.
-  WasHidden();
-}
-
-bool TabContents::NeedToFireBeforeUnload() {
-  // TODO(creis): Should we fire even for interstitial pages?
-  return notify_disconnection() &&
-      !showing_interstitial_page() &&
-      !GetRenderViewHost()->SuddenTerminationAllowed();
-}
-
 // TODO(adriansc): Remove this method once refactoring changed all call sites.
 TabContents* TabContents::OpenURL(const GURL& url,
                                   const GURL& referrer,
                                   WindowOpenDisposition disposition,
                                   content::PageTransition transition) {
   // For specifying a referrer, use the version of OpenURL taking OpenURLParams.
   DCHECK(referrer.is_empty());
   return OpenURL(OpenURLParams(url, content::Referrer(), disposition,
                                transition, false));
 }
@@ skipping 225 matching lines @@
 }
 
 bool TabContents::IsActiveEntry(int32 page_id) {
   NavigationEntry* active_entry = controller_.GetActiveEntry();
   return (active_entry != NULL &&
           active_entry->site_instance() == GetSiteInstance() &&
           active_entry->page_id() == page_id);
 }
 
 void TabContents::SetOverrideEncoding(const std::string& encoding) {
-  set_encoding(encoding);
+  SetEncoding(encoding);
   GetRenderViewHost()->Send(new ViewMsg_SetPageEncoding(
       GetRenderViewHost()->routing_id(), encoding));
 }
 
 void TabContents::ResetOverrideEncoding() {
-  reset_encoding();
+  encoding_.clear();
   GetRenderViewHost()->Send(new ViewMsg_ResetPageEncodingToDefault(
       GetRenderViewHost()->routing_id()));
 }
 
 void TabContents::OnCloseStarted() {
   if (tab_close_start_time_.is_null())
     tab_close_start_time_ = base::TimeTicks::Now();
 }
 
 bool TabContents::ShouldAcceptDragAndDrop() const {
@@ skipping 569 matching lines @@
   if (!notify_disconnection_)
     return;
 
   notify_disconnection_ = false;
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_CONTENTS_DISCONNECTED,
       content::Source<TabContents>(this),
       content::NotificationService::NoDetails());
 }
 
-const base::PropertyBag* TabContents::GetPropertyBag() const {
-  return &property_bag_;
-}
-
-base::PropertyBag* TabContents::GetPropertyBag() {
-  return &property_bag_;
-}
-
-content::WebContentsDelegate* TabContents::GetDelegate() {
-  return delegate_;
-}
-
-void TabContents::SetDelegate(content::WebContentsDelegate* delegate) {
-  // TODO(cbentzel): remove this debugging code?
-  if (delegate == delegate_)
-    return;
-  if (delegate_)
-    delegate_->Detach(this);
-  delegate_ = delegate;
-  if (delegate_)
-    delegate_->Attach(this);
-}
-
-RenderViewHost* TabContents::GetRenderViewHost() const {
-  return render_manager_.current_host();
-}
-
-RenderWidgetHostView* TabContents::GetRenderWidgetHostView() const {
-  return render_manager_.GetRenderWidgetHostView();
-}
-
-TabContentsView* TabContents::GetView() const {
-  return view_.get();
-}
-
 RenderViewHostDelegate::View* TabContents::GetViewDelegate() {
   return view_.get();
 }
 
 RenderViewHostDelegate::RendererManagement*
 TabContents::GetRendererManagementDelegate() {
   return &render_manager_;
 }
 
 content::RendererPreferences TabContents::GetRendererPrefs(
@@ skipping 36 matching lines @@
 }
 
 void TabContents::RenderViewReady(RenderViewHost* rvh) {
   if (rvh != GetRenderViewHost()) {
     // Don't notify the world, since this came from a renderer in the
     // background.
     return;
   }
 
   NotifyConnected();
-  bool was_crashed = is_crashed();
+  bool was_crashed = IsCrashed();
   SetIsCrashed(base::TERMINATION_STATUS_STILL_RUNNING, 0);
 
   // Restore the focus to the tab (otherwise the focus will be on the top
   // window).
   if (was_crashed && !FocusLocationBarByDefault() &&
       (!delegate_ || delegate_->ShouldFocusPageAfterCrash())) {
     Focus();
   }
 
   FOR_EACH_OBSERVER(TabContentsObserver, observers_, RenderViewReady());
 }
 
 void TabContents::RenderViewGone(RenderViewHost* rvh,
                                  base::TerminationStatus status,
                                  int error_code) {
   if (rvh != GetRenderViewHost()) {
     // The pending page's RenderViewHost is gone.
     return;
   }
 
   SetIsLoading(false, NULL);
   NotifyDisconnected();
   SetIsCrashed(status, error_code);
-  GetView()->OnTabCrashed(crashed_status(), crashed_error_code());
+  GetView()->OnTabCrashed(GetCrashedStatus(), crashed_error_code_);
 
   FOR_EACH_OBSERVER(TabContentsObserver,
                     observers_,
-                    RenderViewGone(crashed_status()));
+                    RenderViewGone(GetCrashedStatus()));
 }
 
 void TabContents::RenderViewDeleted(RenderViewHost* rvh) {
   render_manager_.RenderViewDeleted(rvh);
   FOR_EACH_OBSERVER(TabContentsObserver, observers_, RenderViewDeleted(rvh));
 }
 
 void TabContents::DidNavigate(RenderViewHost* rvh,
                               const ViewHostMsg_FrameNavigate_Params& params) {
   if (content::PageTransitionIsMainFrame(params.transition))
@@ skipping 101 matching lines @@
   if (!UpdateTitleForEntry(entry, title))
     return;
 
   // Broadcast notifications when the UI should be updated.
   if (entry == controller_.GetEntryAtOffset(0))
     NotifyNavigationStateChanged(INVALIDATE_TITLE);
 }
 
 void TabContents::UpdateEncoding(RenderViewHost* render_view_host,
                                  const std::string& encoding) {
-  set_encoding(encoding);
+  SetEncoding(encoding);
 }
 
 void TabContents::UpdateTargetURL(int32 page_id, const GURL& url) {
   if (delegate_)
     delegate_->UpdateTargetURL(this, page_id, url);
 }
 
 void TabContents::Close(RenderViewHost* rvh) {
   // The UI may be in an event-tracking loop, such as between the
   // mouse-down and mouse-up in text selection or a button click.
@@ skipping 406 matching lines @@
 }
 
 gfx::NativeWindow TabContents::GetDialogRootWindow() const {
   return view_->GetTopLevelNativeWindow();
 }
 
 void TabContents::OnDialogShown() {
   Activate();
 }
 
-void TabContents::set_encoding(const std::string& encoding) {
+void TabContents::SetEncoding(const std::string& encoding) {
   encoding_ = content::GetContentClient()->browser()->
       GetCanonicalEncodingNameByAliasName(encoding);
 }
 
 void TabContents::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = GetView()->CreateViewForWidget(rvh);
   // Can be NULL during tests.
   if (rwh_view)
     rwh_view->SetSize(GetView()->GetContainerSize());
 }
 
 bool TabContents::GotResponseToLockMouseRequest(bool allowed) {
   return GetRenderViewHost() ?
       GetRenderViewHost()->GotResponseToLockMouseRequest(allowed) : false;
 }