Enable multiple spellcheck fetchers in spelling service client

This CL enables multiple fetcher objects in spelling service client in
preparation for sending feedback to the spelling service.

BUG=170514


Review URL: https://chromiumcodereview.appspot.com/12386053

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@186291 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 49 insertions, 28 deletions

diff --git a/chrome/browser/spellchecker/spellcheck_message_filter.cc b/chrome/browser/spellchecker/spellcheck_message_filter.cc
index f0af9b5..dd328a5 100644
--- a/chrome/browser/spellchecker/spellcheck_message_filter.cc
+++ b/chrome/browser/spellchecker/spellcheck_message_filter.cc
@@ -19,7 +19,8 @@
 using content::BrowserThread;
 
 SpellCheckMessageFilter::SpellCheckMessageFilter(int render_process_id)
-    : render_process_id_(render_process_id)
+    : render_process_id_(render_process_id),
+      client_(new SpellingServiceClient)
 #if !defined(OS_MACOSX)
       ,
       route_id_(0),
@@ -119,7 +120,6 @@ void SpellCheckMessageFilter::OnTextCheckComplete(
                                                 success,
                                                 text,
                                                 results));
-  client_.reset();
 }
 
 // CallSpellingService always executes the callback OnTextCheckComplete.
@@ -132,7 +132,6 @@ void SpellCheckMessageFilter::CallSpellingService(int document_tag,
   if (host)
     profile = Profile::FromBrowserContext(host->GetBrowserContext());
 
-  client_.reset(new SpellingServiceClient);
   client_->RequestTextCheck(
     profile, SpellingServiceClient::SPELLCHECK, text,
     base::Bind(&SpellCheckMessageFilter::OnTextCheckComplete,
diff --git a/chrome/browser/spellchecker/spelling_service_client.cc b/chrome/browser/spellchecker/spelling_service_client.cc
index ce6b22d..6d808f4 100644
--- a/chrome/browser/spellchecker/spelling_service_client.cc
+++ b/chrome/browser/spellchecker/spelling_service_client.cc
@@ -10,6 +10,7 @@
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
+#include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
@@ -62,6 +63,8 @@ SpellingServiceClient::SpellingServiceClient() {
 }
 
 SpellingServiceClient::~SpellingServiceClient() {
+  STLDeleteContainerPairPointers(spellcheck_fetchers_.begin(),
+                                 spellcheck_fetchers_.end());
 }
 
 bool SpellingServiceClient::RequestTextCheck(
@@ -107,14 +110,13 @@ bool SpellingServiceClient::RequestTextCheck(
       api_key.c_str());
 
   GURL url = GURL(kSpellingServiceURL);
-  fetcher_.reset(CreateURLFetcher(url));
-  fetcher_->SetRequestContext(profile->GetRequestContext());
-  fetcher_->SetUploadData("application/json", request);
-  fetcher_->SetLoadFlags(
+  net::URLFetcher* fetcher = CreateURLFetcher(url);
+  fetcher->SetRequestContext(profile->GetRequestContext());
+  fetcher->SetUploadData("application/json", request);
+  fetcher->SetLoadFlags(
       net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES);
-  fetcher_->Start();
-  text_ = text;
-  callback_ = callback;
+  spellcheck_fetchers_[fetcher] = new TextCheckCallbackData(callback, text);
+  fetcher->Start();
   return true;
 }
 
@@ -161,17 +163,31 @@ bool SpellingServiceClient::IsAvailable(Profile* profile, ServiceType type) {
   }
 }
 
+SpellingServiceClient::TextCheckCallbackData::TextCheckCallbackData(
+    TextCheckCompleteCallback callback,
+    string16 text)
+      : callback(callback),
+        text(text) {
+}
+
+SpellingServiceClient::TextCheckCallbackData::~TextCheckCallbackData() {
+}
+
 void SpellingServiceClient::OnURLFetchComplete(
     const net::URLFetcher* source) {
-  scoped_ptr<net::URLFetcher> clean_up_fetcher(fetcher_.release());
+  DCHECK(spellcheck_fetchers_[source]);
+  scoped_ptr<const net::URLFetcher> fetcher(source);
+  scoped_ptr<TextCheckCallbackData>
+      callback_data(spellcheck_fetchers_[fetcher.get()]);
   bool success = false;
   std::vector<SpellCheckResult> results;
-  if (source->GetResponseCode() / 100 == 2) {
+  if (fetcher->GetResponseCode() / 100 == 2) {
     std::string data;
-    source->GetResponseAsString(&data);
+    fetcher->GetResponseAsString(&data);
     success = ParseResponse(data, &results);
   }
-  callback_.Run(success, text_, results);
+  callback_data->callback.Run(success, callback_data->text, results);
+  spellcheck_fetchers_.erase(fetcher.get());
 }
 
 net::URLFetcher* SpellingServiceClient::CreateURLFetcher(const GURL& url) {
diff --git a/chrome/browser/spellchecker/spelling_service_client.h b/chrome/browser/spellchecker/spelling_service_client.h
index 5b55b57..b0ee720 100644
--- a/chrome/browser/spellchecker/spelling_service_client.h
+++ b/chrome/browser/spellchecker/spelling_service_client.h
@@ -5,6 +5,7 @@
 #ifndef CHROME_BROWSER_SPELLCHECKER_SPELLING_SERVICE_CLIENT_H_
 #define CHROME_BROWSER_SPELLCHECKER_SPELLING_SERVICE_CLIENT_H_
 
+#include <map>
 #include <string>
 #include <vector>
 
@@ -74,9 +75,6 @@ class SpellingServiceClient : public net::URLFetcherDelegate {
   SpellingServiceClient();
   virtual ~SpellingServiceClient();
 
-  // net::URLFetcherDelegate implementation.
-  virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
-
   // Sends a text-check request to the Spelling service. When we send a request
   // to the Spelling service successfully, this function returns true. (This
   // does not mean the service finishes checking text successfully.) We will
@@ -90,8 +88,23 @@ class SpellingServiceClient : public net::URLFetcherDelegate {
   static bool IsAvailable(Profile* profile, ServiceType type);
 
  private:
+  struct TextCheckCallbackData {
+    TextCheckCallbackData(TextCheckCompleteCallback callback, string16 text);
+    ~TextCheckCallbackData();
+
+    // The callback function to be called when we receive a response from the
+    // Spelling service and parse it.
+    TextCheckCompleteCallback callback;
+
+    // The text checked by the Spelling service.
+    string16 text;
+  };
+
+  // net::URLFetcherDelegate implementation.
+  virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
+
   // Creates a URLFetcher object used for sending a JSON-RPC request. This
-  // function is overriden by unit tests to prevent them from actually sending
+  // function is overridden by unit tests to prevent them from actually sending
   // requests to the Spelling service.
   virtual net::URLFetcher* CreateURLFetcher(const GURL& url);
 
@@ -100,14 +113,7 @@ class SpellingServiceClient : public net::URLFetcherDelegate {
                      std::vector<SpellCheckResult>* results);
 
   // The URLFetcher object used for sending a JSON-RPC request.
-  scoped_ptr<net::URLFetcher> fetcher_;
-
-  // The callback function to be called when we receive a response from the
-  // Spelling service and parse it.
-  TextCheckCompleteCallback callback_;
-
-  // The text checked by the Spelling service.
-  string16 text_;
+  std::map<const net::URLFetcher*, TextCheckCallbackData*> spellcheck_fetchers_;
 };
 
 #endif  // CHROME_BROWSER_SPELLCHECKER_SPELLING_SERVICE_CLIENT_H_
diff --git a/chrome/browser/tab_contents/spelling_menu_observer.cc b/chrome/browser/tab_contents/spelling_menu_observer.cc
index a509393..d6bb9f9 100644
--- a/chrome/browser/tab_contents/spelling_menu_observer.cc
+++ b/chrome/browser/tab_contents/spelling_menu_observer.cc
@@ -36,7 +36,8 @@ using content::BrowserThread;
 SpellingMenuObserver::SpellingMenuObserver(RenderViewContextMenuProxy* proxy)
     : proxy_(proxy),
       loading_frame_(0),
-      succeeded_(false) {
+      succeeded_(false),
+      client_(new SpellingServiceClient) {
   if (proxy && proxy->GetProfile()) {
     integrate_spelling_service_.Init(prefs::kSpellCheckUseSpellingService,
                                      proxy->GetProfile()->GetPrefs());
@@ -103,7 +104,6 @@ void SpellingMenuObserver::InitMenu(const content::ContextMenuParams& params) {
     SpellingServiceClient::ServiceType type = SpellingServiceClient::SUGGEST;
     if (useSpellingService)
       type = SpellingServiceClient::SPELLCHECK;
-    client_.reset(new SpellingServiceClient);
     bool result = client_->RequestTextCheck(
         profile, type, params.misspelled_word,
         base::Bind(&SpellingMenuObserver::OnTextCheckComplete,