BrowserContext should simply own DownloadManager

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 37 matching lines @@
   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.
 // 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.)
+// TODO: Transition to finish when manager goes down.

[benjhayden, 2013/05/17 14:50:03]

Does this require more than `if (waiting_)
base::MessageLoopForUI::current()->Quit();`?

[cmarcelo, 2013/05/20 15:22:06]

It would work in current code base, but would break the concept of "Finished"
for this object. Its documentation states that we can wait or probe ourselves
(via IsFinished()), quitting the message loop works for the former but not the
latter.

I'll try to fix this, though.

 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.
   };
@@ skipping 12 matching lines @@
   // Return true if everything's happened that we're configured for.
   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.
@@ skipping 114 matching lines @@
 
   // We are in the message loop.
   bool waiting_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadTestItemCreationObserver);
 };
 
 }  // namespace content`
 
 #endif  // CONTENT_TEST_DOWNLOAD_TEST_OBSERVER_H_