Get rid of a bunch of tab_contents.h includes from chrome. These are all trivial changes to use W...

chrome/browser/download/download_request_limiter.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 "chrome/browser/download/download_request_limiter.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "chrome/browser/download/download_request_infobar_delegate.h"
 #include "chrome/browser/infobars/infobar_tab_helper.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper_delegate.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
-#include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 
 using content::BrowserThread;
 using content::NavigationController;
 using content::NavigationEntry;
 using content::WebContents;
 
 // TabDownloadState ------------------------------------------------------------
 
 DownloadRequestLimiter::TabDownloadState::TabDownloadState(
@@ skipping 33 matching lines @@
   if (status_ != DownloadRequestLimiter::ALLOW_ALL_DOWNLOADS &&
       status_ != DownloadRequestLimiter::DOWNLOADS_NOT_ALLOWED) {
     // Revert to default status.
     host_->Remove(this);
     // WARNING: We've been deleted.
     return;
   }
 }
 
 void DownloadRequestLimiter::TabDownloadState::PromptUserForDownload(
-    TabContents* tab,
+    WebContents* tab,
     DownloadRequestLimiter::Callback* callback) {
   callbacks_.push_back(callback);
 
   if (is_showing_prompt())
     return;  // Already showing prompt.
 
   if (DownloadRequestLimiter::delegate_) {
     NotifyCallbacks(DownloadRequestLimiter::delegate_->ShouldAllowDownload());
   } else {
     InfoBarTabHelper* infobar_helper =
@@ skipping 105 matching lines @@
 DownloadRequestLimiter::DownloadRequestLimiter() {
 }
 
 DownloadRequestLimiter::~DownloadRequestLimiter() {
   // All the tabs should have closed before us, which sends notification and
   // removes from state_map_. As such, there should be no pending callbacks.
   DCHECK(state_map_.empty());
 }
 
 DownloadRequestLimiter::DownloadStatus
-    DownloadRequestLimiter::GetDownloadStatus(TabContents* tab) {
+    DownloadRequestLimiter::GetDownloadStatus(WebContents* tab) {
   TabDownloadState* state = GetDownloadState(&tab->GetController(), NULL, false);
   return state ? state->download_status() : ALLOW_ONE_DOWNLOAD;
 }
 
 void DownloadRequestLimiter::CanDownloadOnIOThread(int render_process_host_id,
                                                    int render_view_id,
                                                    int request_id,
                                                    Callback* callback) {
   // This is invoked on the IO thread. Schedule the task to run on the UI
   // thread so that we can query UI state.
@@ skipping 35 matching lines @@
   state_map_[controller] = state;
   return state;
 }
 
 void DownloadRequestLimiter::CanDownload(int render_process_host_id,
                                          int render_view_id,
                                          int request_id,
                                          Callback* callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  TabContents* originating_tab =
-      tab_util::GetTabContentsByID(render_process_host_id, render_view_id);
+  WebContents* originating_tab =
+      tab_util::GetWebContentsByID(render_process_host_id, render_view_id);
   if (!originating_tab) {
     // The tab was closed, don't allow the download.
     ScheduleNotification(callback, false);
     return;
   }
 
   CanDownloadImpl(
       TabContentsWrapper::GetCurrentWrapperForContents(originating_tab),
       request_id,
       callback);
@@ skipping 16 matching lines @@
 
   // If the tab requesting the download is a constrained popup that is not
   // shown, treat the request as if it came from the parent.
   TabContentsWrapper* effective_wrapper = originating_tab;
   if (effective_wrapper->blocked_content_tab_helper()->delegate()) {
     effective_wrapper = effective_wrapper->blocked_content_tab_helper()->
         delegate()->GetConstrainingContentsWrapper(effective_wrapper);
   }
 
   TabDownloadState* state = GetDownloadState(
-      &effective_wrapper->tab_contents()->GetController(),
+      &effective_wrapper->web_contents()->GetController(),
       &tab->GetController(), true);
   switch (state->download_status()) {
     case ALLOW_ALL_DOWNLOADS:
       if (state->download_count() && !(state->download_count() %
             DownloadRequestLimiter::kMaxDownloadsAtOnce))
         state->set_download_status(PROMPT_BEFORE_DOWNLOAD);
       ScheduleNotification(callback, true);
       state->increment_download_count();
       break;
 
     case ALLOW_ONE_DOWNLOAD:
       state->set_download_status(PROMPT_BEFORE_DOWNLOAD);
       ScheduleNotification(callback, true);
       break;
 
     case DOWNLOADS_NOT_ALLOWED:
       ScheduleNotification(callback, false);
       break;
 
     case PROMPT_BEFORE_DOWNLOAD:
-      state->PromptUserForDownload(effective_wrapper->tab_contents(), callback);
+      state->PromptUserForDownload(effective_wrapper->web_contents(), callback);
       state->increment_download_count();
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 void DownloadRequestLimiter::ScheduleNotification(Callback* callback,
                                                   bool allow) {
@@ skipping 13 matching lines @@
 
 void DownloadRequestLimiter::Remove(TabDownloadState* state) {
   DCHECK(ContainsKey(state_map_, state->controller()));
   state_map_.erase(state->controller());
   delete state;
 }
 
 // static
 DownloadRequestLimiter::TestingDelegate* DownloadRequestLimiter::delegate_ =
     NULL;