History: Reload page only after web history deletion has completed.

chrome/browser/history/web_history_service.cc

 // 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.
 
 #include "chrome/browser/history/web_history_service.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 35 matching lines @@
   virtual ~RequestImpl() {
   }
 
   // Returns the response code received from the server, which will only be
   // valid if the request succeeded.
   int response_code() { return response_code_; }
 
   // Returns the contents of the response body received from the server.
   const std::string& response_body() { return response_body_; }
 
+  virtual bool is_pending() OVERRIDE { return is_pending_; }
+
  private:
   friend class history::WebHistoryService;
 
   typedef base::Callback<void(Request*, bool)> CompletionCallback;
 
   RequestImpl(Profile* profile,
               const std::string& url,
               const CompletionCallback& callback)
       : profile_(profile),
         url_(GURL(url)),
         response_code_(0),
         auth_retry_count_(0),
-        callback_(callback) {
+        callback_(callback),
+        is_pending_(false) {
   }
 
   // Tells the request to do its thang.
   void Start() {
     OAuth2TokenService::ScopeSet oauth_scopes;
     oauth_scopes.insert(kHistoryOAuthScope);
 
     OAuth2TokenService* token_service =
         OAuth2TokenServiceFactory::GetForProfile(profile_);
     token_request_ = token_service->StartRequest(oauth_scopes, this);
+    is_pending_ = true;
   }
 
   // content::URLFetcherDelegate interface.
   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE {
     DCHECK_EQ(source, url_fetcher_.get());
     response_code_ = url_fetcher_->GetResponseCode();
 
     // If the response code indicates that the token might not be valid,
     // invalidate the token and try again.
     if (response_code_ == net::HTTP_UNAUTHORIZED && ++auth_retry_count_ <= 1) {
       OAuth2TokenService::ScopeSet oauth_scopes;
       oauth_scopes.insert(kHistoryOAuthScope);
       OAuth2TokenServiceFactory::GetForProfile(profile_)->InvalidateToken(
           oauth_scopes, access_token_);
 
       access_token_ = std::string();
       Start();
       return;
     }
     url_fetcher_->GetResponseAsString(&response_body_);
     url_fetcher_.reset();
     callback_.Run(this, true);
+    is_pending_ = false;
   }
 
   // OAuth2TokenService::Consumer interface.
   virtual void OnGetTokenSuccess(
       const OAuth2TokenService::Request* request,
       const std::string& access_token,
       const base::Time& expiration_time) OVERRIDE {
     token_request_.reset();
     DCHECK(!access_token.empty());
     access_token_ = access_token;
 
     // Got an access token -- start the actual API request.
     url_fetcher_.reset(CreateUrlFetcher(access_token));
     url_fetcher_->Start();
   }
 
   virtual void OnGetTokenFailure(
       const OAuth2TokenService::Request* request,
       const GoogleServiceAuthError& error) OVERRIDE {
     token_request_.reset();
     LOG(WARNING) << "Failed to get OAuth token: " << error.ToString();
     callback_.Run(this, false);
+    is_pending_ = false;

[James Hawkins, 2013/04/17 16:59:25]

This seems fragile.  Can we not use callback_ somehow, like callback_.hasRun (I
don't remember what the exact syntax is)?

   }
 
   // Helper for creating a new URLFetcher for the API request.
   net::URLFetcher* CreateUrlFetcher(const std::string& access_token) {
     net::URLFetcher::RequestType request_type = post_data_.empty() ?
         net::URLFetcher::GET : net::URLFetcher::POST;
     net::URLFetcher* fetcher = net::URLFetcher::Create(
         url_, request_type, this);
     fetcher->SetRequestContext(profile_->GetRequestContext());
     fetcher->SetMaxRetriesOn5xx(kMaxRetries);
@@ skipping 33 matching lines @@
 
   // Holds the response body received from the server.
   std::string response_body_;
 
   // The number of times this request has already been retried due to
   // authorization problems.
   int auth_retry_count_;
 
   // The callback to execute when the query is complete.
   CompletionCallback callback_;
+
+  // True if the request was started and has not yet completed, otherwise false.
+  bool is_pending_;
 };
 
 // Extracts a JSON-encoded HTTP response into a DictionaryValue.
 // If |request|'s HTTP response code indicates failure, or if the response
 // body is not JSON, a null pointer is returned.
 scoped_ptr<DictionaryValue> ReadResponse(RequestImpl* request) {
   scoped_ptr<DictionaryValue> result;
   if (request->response_code() == net::HTTP_OK) {
     Value* value = base::JSONReader::Read(request->response_body());
     if (value && value->IsType(base::Value::TYPE_DICTIONARY))
@@ skipping 171 matching lines @@
     base::Time end_time,
     const ExpireWebHistoryCallback& callback) {
   std::vector<ExpireHistoryArgs> expire_list(1);
   expire_list.back().urls = restrict_urls;
   expire_list.back().begin_time = begin_time;
   expire_list.back().end_time = end_time;
   return ExpireHistory(expire_list, callback);
 }
 
 }  // namespace history