Fix DCHECK, memory leak, and refactor PasswordStore to use CancelableRequest

content/browser/cancelable_request.cc

 // 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.
 
 #include "content/browser/cancelable_request.h"
 
-CancelableRequestProvider::CancelableRequestProvider() : next_handle_(1) {
+const CancelableRequestProvider::Handle
+    CancelableRequestProvider::kInvalidHandle = 0;
+const CancelableRequestProvider::Handle
+    CancelableRequestProvider::kFirstHandle = 1;
+
+CancelableRequestProvider::CancelableRequestProvider()
+    : next_handle_(CancelableRequestProvider::kFirstHandle) {
 }
 
 CancelableRequestProvider::~CancelableRequestProvider() {
   // There may be requests whose result callback has not been run yet. We need
   // to cancel them otherwise they may try and call us back after we've been
   // deleted, or do other bad things. This can occur on shutdown (or profile
   // destruction) when a request is scheduled, completed (but not dispatched),
   // then the Profile is deleted.
   base::AutoLock lock(pending_request_lock_);
   while (!pending_requests_.empty())
     CancelRequestLocked(pending_requests_.begin());
 }
 
 CancelableRequestProvider::Handle CancelableRequestProvider::AddRequest(
     CancelableRequestBase* request,
     CancelableRequestConsumerBase* consumer) {
   Handle handle;
   {
     base::AutoLock lock(pending_request_lock_);
 
     handle = next_handle_;
     pending_requests_[next_handle_] = request;
     ++next_handle_;
+    DCHECK_NE(kInvalidHandle, next_handle_);
   }
 
   consumer->OnRequestAdded(this, handle);
 
   request->Init(this, handle, consumer);
   return handle;
 }
 
 void CancelableRequestProvider::CancelRequest(Handle handle) {
   base::AutoLock lock(pending_request_lock_);
   CancelRequestLocked(pending_requests_.find(handle));
 }
 
+CancelableRequestProvider::Handle CancelableRequestProvider::InvalidHandle() {
+  return kInvalidHandle;
+}
+
+bool CancelableRequestProvider::HandleIsValid(Handle handle) {
+  return handle != kInvalidHandle;
+}
+
 void CancelableRequestProvider::CancelRequestLocked(
     const CancelableRequestMap::iterator& item) {
   pending_request_lock_.AssertAcquired();
   if (item == pending_requests_.end()) {
     NOTREACHED() << "Trying to cancel an unknown request";
     return;
   }
 
   item->second->consumer()->OnRequestRemoved(this, item->first);
   item->second->set_canceled();
@@ skipping 43 matching lines @@
 }
 
 void CancelableRequestBase::Init(CancelableRequestProvider* provider,
                                  CancelableRequestProvider::Handle handle,
                                  CancelableRequestConsumerBase* consumer) {
   DCHECK(handle_ == 0 && provider_ == NULL && consumer_ == NULL);
   provider_ = provider;
   consumer_ = consumer;
   handle_ = handle;
 }