Fixed issue with DownloadTestObserver.

chrome/browser/download/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 CHROME_BROWSER_DOWNLOAD_DOWNLOAD_TEST_OBSERVER_H_
 #define CHROME_BROWSER_DOWNLOAD_DOWNLOAD_TEST_OBSERVER_H_
 #pragma once
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager.h"
 
-// Construction of this class defines a system state, based on some number
-// of downloads being seen in a particular state + other events that
-// may occur in the download system.  That state will be recorded if it
-// occurs at any point after construction.  When that state occurs, the class
-// is considered finished.  Callers may either probe for the finished state, or
-// wait on it.
+// 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.)
 class DownloadTestObserver : public content::DownloadManager::Observer,
                              public content::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
   };
 
   // Create an object that will be considered finished when |wait_count|
-  // download items have entered state |download_finished_state|.
+  // download items have entered a terminal state.
   // If |finish_on_select_file| is true, the object will also be
   // considered finished if the DownloadManager raises a
   // SelectFileDialogDisplayed() notification.
-
-  // TODO(rdsmith): Consider rewriting the interface to take a list of events
-  // to treat as completion events.
   DownloadTestObserver(
       content::DownloadManager* download_manager,
       size_t wait_count,
-      content::DownloadItem::DownloadState download_finished_state,
       bool finish_on_select_file,
       DangerousDownloadAction dangerous_download_action);
 
   virtual ~DownloadTestObserver();
 
   // State accessors.
   bool select_file_dialog_seen() const { return select_file_dialog_seen_; }
 
-  // Wait for whatever state was specified in the constructor.
+  // Wait for the requested number of downloads to enter a terminal state.
   void WaitForFinished();
 
   // Return true if everything's happened that we're configured for.
   bool IsFinished() const;
 
   // content::DownloadItem::Observer
   virtual void OnDownloadUpdated(content::DownloadItem* download) OVERRIDE;
   virtual void OnDownloadOpened(content::DownloadItem* download) OVERRIDE {}
 
   // content::DownloadManager::Observer
   virtual void ModelChanged(content::DownloadManager* manager) OVERRIDE;
 
   virtual void SelectFileDialogDisplayed(
       content::DownloadManager* manager, int32 id) OVERRIDE;
 
   size_t NumDangerousDownloadsSeen() const;
 
- private:
+  size_t NumDownloadsSeenInState(
+      content::DownloadItem::DownloadState state) const;

[Randy Smith (Not in Mondays), 2012/03/08 18:25:31]

Up to you, but I'd be more inclined to leave this functionality out of the class
and let the user probe for it separately (maybe by a separate routine on
DownloadTest).

[ahendrickson, 2012/03/08 20:56:34]

It's here specifically for IN_PROGRESS tests, which could transition out of that
into another state before checking in the tests.

[Randy Smith (Not in Mondays), 2012/03/09 18:39:38]

Ah, makes sense.  Ok.

+
+ protected:
   typedef std::set<content::DownloadItem*> DownloadSet;
 
-  // 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(content::DownloadItem* download);
+  // Maps states to the number of times they have been encountered
+  typedef std::map<content::DownloadItem::DownloadState, size_t> StateMap;
 
-  void SignalIfFinished();
+  // Called to see if a download item is in a final state.
+  virtual bool IsDownloadInFinalState(content::DownloadItem* download) = 0;
 
   // The observed download manager.
   scoped_refptr<content::DownloadManager> download_manager_;

[benjhayden, 2012/03/08 20:30:02]

Would it be too much trouble to keep member fields private and provide protected
accessors as needed? 'Yes' is an acceptable answer, although 'not this CL' would
be preferable. It's just a readability issue.

[ahendrickson, 2012/03/08 21:28:55]

My preference would be to punt this to another CL, but if people feel strongly
enough about it I'll do it here.

[Randy Smith (Not in Mondays), 2012/03/09 18:39:38]

For this kind of issue, it's useful to look at whether there's something about
the design that's problematic (i.e. assume it's a code smell--where's the
cheese?).  In this case, it looks to me as if the reason all of these member
variables are accessed by the derived classes is because they're accessed in the
derived class constructors, code that is duplicated between derived class
constructors (another code smell, already noted).  You pointed out that we
needed that to be executed after the base class constructor was executed so that
the virtual function table for the base class would be initialized (good catch,
and nice bullet dodge).  Well, is there any way we can execute that common code
in the base class after base class construction?  (I.e. I'm suggesting making an
Init() base class method that's called from the derived class constructor.)

To answer your basic issue above, I dislike letting real design/encapsulation
issues in before landing.  If it was just readability I'd be ok with a new CL,
but based on my analysis above, it's not.  Let me know if you disagree.

[ahendrickson, 2012/03/09 20:07:23]

OK, done.

 
   // 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_;
-
-  // The number of downloads to wait on completing.
-  size_t wait_count_;
+  // The map of states to the number of times they have been observed since
+  // we started looking.
+  // Recorded at the time downloads_observed_ is recorded, but cleared in the
+  // constructor to exclude pre-existing states.
+  StateMap states_observed_;
 
   // The number of downloads entered in final state in initial
   // ModelChanged().  We use |finished_downloads_| to track the incoming
   // transitions to final state we should ignore, and to track the
   // number of final state transitions that occurred between
   // construction and return from wait.  But some downloads may be in our
   // final state (and thus be entered into |finished_downloads_|) when we
   // construct this class.  We don't want to count those in our transition
   // to finished.
   int finished_downloads_at_construction_;
 
+ private:
+  // 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(content::DownloadItem* download);
+
+  void SignalIfFinished();
+
+  // 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_;
+
+  // The number of downloads to wait on completing.
+  size_t wait_count_;
+
   // Whether an internal message loop has been started and must be quit upon
   // all downloads completing.
   bool waiting_;
 
-  // The state on which to consider the DownloadItem finished.
-  content::DownloadItem::DownloadState download_finished_state_;
-
   // True if we should transition the DownloadTestObserver to finished if
   // the select file dialog comes up.
   bool finish_on_select_file_;
 
   // True if we've seen the select file dialog.
   bool select_file_dialog_seen_;
 
   // 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_;
 
   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(
+      content::DownloadManager* download_manager,
+      size_t wait_count,
+      bool finish_on_select_file,
+      DangerousDownloadAction dangerous_download_action);
+
+  virtual ~DownloadTestObserverTerminal();
+
+ private:
+  virtual bool IsDownloadInFinalState(content::DownloadItem* download) OVERRIDE;
+
+  DISALLOW_COPY_AND_ASSIGN(DownloadTestObserverTerminal);
+};
+
+// Detects changes to the downloads after construction.
+// Finishes when one of the following happens:
+//   - A specified number of downloads change to the IN_PROGRESS state.

[Randy Smith (Not in Mondays), 2012/03/08 18:25:31]

You haven't specified the behavior on a dangerous download (which I'm suggesting
changing elsewhere) or on a select file prompt.  The select file prompt behavior
I'm feeling iffy about--if the select file dialog is popped up, that will block
the download visibly transitioning to the IN_PROGRESS state, and if the select
file dialog is nulled, a "finish_on_select_file" may result in an exit before
the downloads really get to IN_PROGRESS.  So you might want to actually give the
user control over select file dialog behavior?  (I think I said something
different than this earlier (and my apologies for the mixed message).  That
means that one of the two times I'm confused--I obviously believe it's the
previous one, but you might want to check the code.  I think that we don't see
IN_PROGRESS downloads until after entry into history, which is delayed on the
select file dialog--that's the important set of events to figure out.)

[ahendrickson, 2012/03/08 20:56:34]

I think we're in trouble if the select file dialog appears, no matter what.  The
tests can specify to automatically accept the default and avoid them.

I changed it to ignoring the select file dialog for IN_PROGRESS tests.

[Randy Smith (Not in Mondays), 2012/03/09 18:39:38]

Confused, and I'd like to be unconfused before we land this.  I think we're in
the same position with IN_PROGRESS that we've been previously, and that we want
the full select functionality.  Specifically:

* If the test is testing to see if the select file dialog appears and wants to
exit when it gets that dialog, ignoring won't be right (we may not have any
IN_PROGRESS tests in this space, so this may be a comment about having options
for future tests).

* If the test is expecting the select file dialog and wants to blow past it,
it'll null the dialog out.  However, this will still fire the select file dialog
notification (done from a lower level), so *not* ignoring it won't be right for
these tests.

So I think we need to port over the control logic from the old code.  Do you see
something I'm missing?

[ahendrickson, 2012/03/09 20:07:23]

OK, added the parameter to DownloadObserverTestInProgress, and updated the
comments.

+// Callers may either probe for the finished state, or wait on it.
+//

[Randy Smith (Not in Mondays), 2012/03/08 18:25:31]

nit: Could you nuke the blank comment line?  I think that's not the usual
custom.

[ahendrickson, 2012/03/08 20:56:34]

Done.

+class DownloadTestObserverInProgress : public DownloadTestObserver {
+ public:
+  // Create an object that will be considered finished when |wait_count|
+  // download items have entered state |IN_PROGRESS|.
+
+  DownloadTestObserverInProgress(
+      content::DownloadManager* download_manager,
+      size_t wait_count);
+
+  virtual ~DownloadTestObserverInProgress();
+
+ private:
+  virtual bool IsDownloadInFinalState(content::DownloadItem* download) OVERRIDE;
+
+  DISALLOW_COPY_AND_ASSIGN(DownloadTestObserverInProgress);
+};
+
 // The WaitForFlush() method on this class returns after:
 //      * There are no IN_PROGRESS download items remaining on the
 //        DownloadManager.
 //      * There have been two round trip messages through the file and
 //        IO threads.
 // This almost certainly means that a Download cancel has propagated through
 // the system.
 class DownloadTestFlushObserver
     : public content::DownloadManager::Observer,
       public content::DownloadItem::Observer,
@@ skipping 29 matching lines @@
   void PingIOThread(int cycle);
 
   content::DownloadManager* download_manager_;
   DownloadSet downloads_observed_;
   bool waiting_for_zero_inprogress_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadTestFlushObserver);
 };
 
 #endif  // CHROME_BROWSER_DOWNLOAD_DOWNLOAD_TEST_OBSERVER_H_