Convert WebContents to return a content::NavigationController instead of the implementation. Upda...

chrome/browser/download/download_request_limiter.h

 // 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.
 
 #ifndef CHROME_BROWSER_DOWNLOAD_DOWNLOAD_REQUEST_LIMITER_H_
 #define CHROME_BROWSER_DOWNLOAD_DOWNLOAD_REQUEST_LIMITER_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
 class DownloadRequestInfoBarDelegate;
-class NavigationController;
 class TabContents;
 class TabContentsWrapper;
 
 namespace content {
+class NavigationController;
 class WebContents;
 }
 
 // DownloadRequestLimiter is responsible for determining whether a download
 // should be allowed or not. It is designed to keep pages from downloading
 // multiple files without user interaction. DownloadRequestLimiter is invoked
 // from ResourceDispatcherHost any time a download begins
 // (CanDownloadOnIOThread). The request is processed on the UI thread, and the
 // request is notified (back on the IO thread) as to whether the download should
 // be allowed or denied.
@@ skipping 42 matching lines @@
   // DownloadRequestLimiter::Remove) as necessary.
   class TabDownloadState : public content::NotificationObserver {
    public:
     // Creates a new TabDownloadState. |controller| is the controller the
     // TabDownloadState tracks the state of and is the host for any dialogs that
     // are displayed. |originating_controller| is used to determine the host of
     // the initial download. If |originating_controller| is null, |controller|
     // is used. |originating_controller| is typically null, but differs from
     // |controller| in the case of a constrained popup requesting the download.
     TabDownloadState(DownloadRequestLimiter* host,
-                     NavigationController* controller,
-                     NavigationController* originating_controller);
+                     content::NavigationController* controller,
+                     content::NavigationController* originating_controller);
     virtual ~TabDownloadState();
 
     // Status of the download.
     void set_download_status(DownloadRequestLimiter::DownloadStatus status) {
       status_ = status;
     }
     DownloadRequestLimiter::DownloadStatus download_status() const {
       return status_;
     }
 
@@ skipping 12 matching lines @@
     // Asks the user if they really want to allow the download.
     // See description above CanDownloadOnIOThread for details on lifetime of
     // callback.
     void PromptUserForDownload(TabContents* tab,
                                DownloadRequestLimiter::Callback* callback);
 
     // Are we showing a prompt to the user?
     bool is_showing_prompt() const { return (infobar_ != NULL); }
 
     // NavigationController we're tracking.
-    NavigationController* controller() const { return controller_; }
+    content::NavigationController* controller() const { return controller_; }
 
     // Invoked from DownloadRequestDialogDelegate. Notifies the delegates and
     // changes the status appropriately. Virtual for testing.
     virtual void Cancel();
     virtual void Accept();
 
    protected:
     // Used for testing.
     TabDownloadState()
         : host_(NULL),
           controller_(NULL),
           status_(DownloadRequestLimiter::ALLOW_ONE_DOWNLOAD),
           download_count_(0),
           infobar_(NULL) {
     }
 
    private:
     // content::NotificationObserver method.
     virtual void Observe(int type,
                          const content::NotificationSource& source,
                          const content::NotificationDetails& details) OVERRIDE;
 
     // Notifies the callbacks as to whether the download is allowed or not.
     // Updates status_ appropriately.
     void NotifyCallbacks(bool allow);
 
     DownloadRequestLimiter* host_;
 
-    NavigationController* controller_;
+    content::NavigationController* controller_;
 
     // Host of the first page the download started on. This may be empty.
     std::string initial_page_host_;
 
     DownloadRequestLimiter::DownloadStatus status_;
 
     size_t download_count_;
 
     // Callbacks we need to notify. This is only non-empty if we're showing a
     // dialog.
@@ skipping 49 matching lines @@
   static void SetTestingDelegate(TestingDelegate* delegate);
 
   // Gets the download state for the specified controller. If the
   // TabDownloadState does not exist and |create| is true, one is created.
   // See TabDownloadState's constructor description for details on the two
   // controllers.
   //
   // The returned TabDownloadState is owned by the DownloadRequestLimiter and
   // deleted when no longer needed (the Remove method is invoked).
   TabDownloadState* GetDownloadState(
-      NavigationController* controller,
-      NavigationController* originating_controller,
+      content::NavigationController* controller,
+      content::NavigationController* originating_controller,
       bool create);
 
   // CanDownloadOnIOThread invokes this on the UI thread. This determines the
   // tab and invokes CanDownloadImpl.
   void CanDownload(int render_process_host_id,
                    int render_view_id,
                    int request_id,
                    Callback* callback);
 
   // Does the work of updating the download status on the UI thread and
@@ skipping 11 matching lines @@
 
   // Removes the specified TabDownloadState from the internal map and deletes
   // it. This has the effect of resetting the status for the tab to
   // ALLOW_ONE_DOWNLOAD.
   void Remove(TabDownloadState* state);
 
   // Maps from tab to download state. The download state for a tab only exists
   // if the state is other than ALLOW_ONE_DOWNLOAD. Similarly once the state
   // transitions from anything but ALLOW_ONE_DOWNLOAD back to ALLOW_ONE_DOWNLOAD
   // the TabDownloadState is removed and deleted (by way of Remove).
-  typedef std::map<NavigationController*, TabDownloadState*> StateMap;
+  typedef std::map<content::NavigationController*, TabDownloadState*> StateMap;
   StateMap state_map_;
 
   static TestingDelegate* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadRequestLimiter);
 };
 
 #endif  // CHROME_BROWSER_DOWNLOAD_DOWNLOAD_REQUEST_LIMITER_H_