DownloadTestObserver should know when the DownloadManager was shutdown

content/public/test/download_test_observer.h

 // Copyright (c) 2012 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 CONTENT_TEST_DOWNLOAD_TEST_OBSERVER_H_
 #define CONTENT_TEST_DOWNLOAD_TEST_OBSERVER_H_
 
 #include <set>
 #include <vector>
 
@@ skipping 31 matching lines @@
 
   DownloadItem* item_;
   EventFilter filter_;
   bool waiting_;
   bool event_seen_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadUpdatedObserver);
 };
 
 // Detects changes to the downloads after construction.
+//
 // Finishes when one of the following happens:
 //   - A specified number of downloads change to a terminal state (defined
 //     in derived classes).
-//   - Specific events, such as a select file dialog.
+//   - The download manager was shutdown.
+//
 // Callers may either probe for the finished state, or wait on it.
-//
-// TODO(rdsmith): Detect manager going down, remove pointer to
-// DownloadManager, transition to finished.  (For right now we
-// just use a scoped_refptr<> to keep it around, but that may cause
-// timeouts on waiting if a DownloadManager::Shutdown() occurs which
-// cancels our in-progress downloads.)
 class DownloadTestObserver : public DownloadManager::Observer,
                              public DownloadItem::Observer {
  public:
   // Action an observer should take if a dangerous download is encountered.
   enum DangerousDownloadAction {
     ON_DANGEROUS_DOWNLOAD_ACCEPT,  // Accept the download
     ON_DANGEROUS_DOWNLOAD_DENY,    // Deny the download
     ON_DANGEROUS_DOWNLOAD_FAIL,    // Fail if a dangerous download is seen
     ON_DANGEROUS_DOWNLOAD_IGNORE   // Make it the callers problem.
   };
 
   // Create an object that will be considered finished when |wait_count|
   // download items have entered a terminal state.
   DownloadTestObserver(DownloadManager* download_manager,
                        size_t wait_count,
                        DangerousDownloadAction dangerous_download_action);
 
   virtual ~DownloadTestObserver();
 
-  // Wait for the requested number of downloads to enter a terminal state.
+  // Wait for one of the finish conditions.
   void WaitForFinished();
 
-  // Return true if everything's happened that we're configured for.
+  // Return true if we reached one of the finish conditions.
   bool IsFinished() const;
 
   // DownloadItem::Observer
   virtual void OnDownloadUpdated(DownloadItem* download) OVERRIDE;
   virtual void OnDownloadDestroyed(DownloadItem* download) OVERRIDE;
 
   // DownloadManager::Observer
   virtual void OnDownloadCreated(
       DownloadManager* manager, DownloadItem* item) OVERRIDE;
+  virtual void ManagerGoingDown(DownloadManager* manager) OVERRIDE;
 
   size_t NumDangerousDownloadsSeen() const;
 
   size_t NumDownloadsSeenInState(DownloadItem::DownloadState state) const;
 
  protected:
   // Only to be called by derived classes' constructors.
   virtual void Init();
 
   // Called to see if a download item is in a final state.
   virtual bool IsDownloadInFinalState(DownloadItem* download) = 0;
 
  private:
   typedef std::set<DownloadItem*> DownloadSet;
 
   // Maps states to the number of times they have been encountered
   typedef std::map<DownloadItem::DownloadState, size_t> StateMap;
 
   // Called when we know that a download item is in a final state.
   // Note that this is not the same as it first transitioning in to the
   // final state; multiple notifications may occur once the item is in
   // that state.  So we keep our own track of transitions into final.
   void DownloadInFinalState(DownloadItem* download);
 
   void SignalIfFinished();
 
+  // Fake user click on "Accept".
+  void AcceptDangerousDownload(int32 download_id);
+
+  // Fake user click on "Deny".
+  void DenyDangerousDownload(int32 download_id);
+
   // The observed download manager.
-  scoped_refptr<DownloadManager> download_manager_;
+  DownloadManager* download_manager_;
 
   // The set of DownloadItem's that have transitioned to their finished state
   // since construction of this object.  When the size of this array
   // reaches wait_count_, we're done.
   DownloadSet finished_downloads_;
 
   // The set of DownloadItem's we are currently observing.  Generally there
   // won't be any overlap with the above; once we see the final state
   // on a DownloadItem, we'll stop observing it.
   DownloadSet downloads_observed_;
@@ skipping 19 matching lines @@
   // Whether an internal message loop has been started and must be quit upon
   // all downloads completing.
   bool waiting_;
 
   // Action to take if a dangerous download is encountered.
   DangerousDownloadAction dangerous_download_action_;
 
   // Holds the download ids which were dangerous.
   std::set<int32> dangerous_downloads_seen_;
 
+  base::WeakPtrFactory<DownloadTestObserver> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(DownloadTestObserver);
 };
 
 class DownloadTestObserverTerminal : public DownloadTestObserver {
  public:
   // Create an object that will be considered finished when |wait_count|
   // download items have entered a terminal state (any but IN_PROGRESS).
-  // If |finish_on_select_file| is true, the object will also be
-  // considered finished if the DownloadManager raises a
-  // SelectFileDialogDisplayed() notification.
   DownloadTestObserverTerminal(
       DownloadManager* download_manager,
       size_t wait_count,
       DangerousDownloadAction dangerous_download_action);
 
   virtual ~DownloadTestObserverTerminal();
 
  private:
   virtual bool IsDownloadInFinalState(DownloadItem* download) OVERRIDE;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadTestObserverTerminal);
 };
 
 // Detects changes to the downloads after construction.
 // Finishes when a specified number of downloads change to the
-// IN_PROGRESS state, or a Select File Dialog has appeared.
+// IN_PROGRESS state, or when the download manager is destroyed.
 // Dangerous downloads are accepted.
 // Callers may either probe for the finished state, or wait on it.
 class DownloadTestObserverInProgress : public DownloadTestObserver {
  public:
   // Create an object that will be considered finished when |wait_count|
   // download items have entered state |IN_PROGRESS|.
-  // If |finish_on_select_file| is true, the object will also be
-  // considered finished if the DownloadManager raises a
-  // SelectFileDialogDisplayed() notification.
   DownloadTestObserverInProgress(
       DownloadManager* download_manager, size_t wait_count);
 
   virtual ~DownloadTestObserverInProgress();
 
  private:
   virtual bool IsDownloadInFinalState(DownloadItem* download) OVERRIDE;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadTestObserverInProgress);
 };
@@ skipping 79 matching lines @@
 
   // We are in the message loop.
   bool waiting_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadTestItemCreationObserver);
 };
 
 }  // namespace content`
 
 #endif  // CONTENT_TEST_DOWNLOAD_TEST_OBSERVER_H_