Fix password automation hooks to get pyauto test testSavePassword working.

content/browser/cancelable_request.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.
 
 // CancelableRequestProviders and Consumers work together to make requests that
 // execute on a background thread in the provider and return data to the
 // consumer. These class collaborate to keep a list of open requests and to
 // make sure that requests to not outlive either of the objects involved in the
 // transaction.
 //
@@ skipping 121 matching lines @@
   // to add a new request. The request's Init() will be called (which is why
   // the consumer is required. The handle to the new request is returned.
   Handle AddRequest(CancelableRequestBase* request,
                     CancelableRequestConsumerBase* consumer);
 
   // Called by the CancelableRequest when the request has executed. It will
   // be removed from the list of pending requests (as opposed to canceling,
   // which will also set some state on the request).
   void RequestCompleted(Handle handle);
 
+  // Identifies whether or not the specified request has already been completed
+  // or canceled, according to whether it exists in |completed_requests_|.
+  bool IsRequestCompleted(Handle handle);
+
  private:
   typedef std::map<Handle, scoped_refptr<CancelableRequestBase> >
       CancelableRequestMap;
 
   // Only call this when you already have acquired pending_request_lock_.
   void CancelRequestLocked(const CancelableRequestMap::iterator& item);
 
   friend class CancelableRequestBase;
 
   base::Lock pending_request_lock_;
 
   // Lists all outstanding requests. Protected by the |lock_|.
   CancelableRequestMap pending_requests_;
 
+  // Lists all completed or canceled requests.  Protected by the |lock_|.
+  CancelableRequestMap completed_requests_;
+
   // The next handle value we will return. Protected by the |lock_|.
   int next_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(CancelableRequestProvider);
 };
 
 // CancelableRequestConsumer --------------------------------------------------
 //
 // Classes wishing to make requests on a provider should have an instance of
 // this class. Callers will need to pass a pointer to this consumer object
@@ skipping 368 matching lines @@
 
   // Initializes the object with the particulars from the provider. It may only
   // be called once (it is called by the provider, which is a friend).
   void Init(CancelableRequestProvider* provider,
             CancelableRequestProvider::Handle handle,
             CancelableRequestConsumerBase* consumer);
 
   // Tells the provider that the request is complete, which then tells the
   // consumer.
   void NotifyCompleted() const {
-    provider_->RequestCompleted(handle());
-    consumer_->DidExecute(provider_, handle_);
+    if (!provider_->IsRequestCompleted(handle())) {
+      provider_->RequestCompleted(handle());
+      consumer_->DidExecute(provider_, handle_);
+    }
   }
 
   // Cover method for CancelableRequestConsumerBase::WillExecute.
   void WillExecute() {
     consumer_->WillExecute(provider_, handle_);
   }
 
   // The message loop that this request was created on. The callback will
   // happen on the same thread.
   MessageLoop* callback_thread_;
@@ skipping 139 matching lines @@
   }
 
   // The value.
   Type value;
 
  protected:
   virtual ~CancelableRequest1() {}
 };
 
 #endif  // CONTENT_BROWSER_CANCELABLE_REQUEST_H_