src/chrome/browser/spellchecker/spelling_service_client.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_SPELLCHECKER_SPELLING_SERVICE_CLIENT_H_
   6 #define CHROME_BROWSER_SPELLCHECKER_SPELLING_SERVICE_CLIENT_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/callback.h"
  13 #include "base/compiler_specific.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/strings/string16.h"
  16 #include "net/url_request/url_fetcher_delegate.h"
  17
  18 class GURL;
  19 class TextCheckClientDelegate;
  20 struct SpellCheckResult;
  21
  22 namespace content {
  23 class BrowserContext;
  24 }
  25
  26 namespace net {
  27 class URLFetcher;
  28 }  // namespace net
  29
  30 // A class that encapsulates a JSON-RPC call to the Spelling service to check
  31 // text there. This class creates a JSON-RPC request, sends the request to the
  32 // service with URLFetcher, parses a response from the service, and calls a
  33 // provided callback method. When a user deletes this object before it finishes
  34 // a JSON-RPC call, this class cancels the JSON-RPC call without calling the
  35 // callback method. A simple usage is creating a SpellingServiceClient and
  36 // calling its RequestTextCheck method as listed in the following snippet.
  37 //
  38 //   class MyClient {
  39 //    public:
  40 //     MyClient();
  41 //     virtual ~MyClient();
  42 //
  43 //     void OnTextCheckComplete(
  44 //         int tag,
  45 //         bool success,
  46 //         const std::vector<SpellCheckResult>& results) {
  47 //       ...
  48 //     }
  49 //
  50 //     void MyTextCheck(BrowserContext* context, const string16& text) {
  51 //        client_.reset(new SpellingServiceClient);
  52 //        client_->RequestTextCheck(context, 0, text,
  53 //            base::Bind(&MyClient::OnTextCheckComplete,
  54 //                       base::Unretained(this));
  55 //     }
  56 //    private:
  57 //     scoped_ptr<SpellingServiceClient> client_;
  58 //   };
  59 //
  60 class SpellingServiceClient : public net::URLFetcherDelegate {
  61  public:
  62   // Service types provided by the Spelling service. The Spelling service
  63   // consists of a couple of backends:
  64   // * SUGGEST: Retrieving suggestions for a word (used by Google Search), and;
  65   // * SPELLCHECK: Spellchecking text (used by Google Docs).
  66   // This type is used for choosing a backend when sending a JSON-RPC request to
  67   // the service.
  68   enum ServiceType {
  69     SUGGEST = 1,
  70     SPELLCHECK = 2,
  71   };
  72   typedef base::Callback<void(
  73       bool /* success */,
  74       const string16& /* text */,
  75       const std::vector<SpellCheckResult>& /* results */)>
  76           TextCheckCompleteCallback;
  77
  78   SpellingServiceClient();
  79   virtual ~SpellingServiceClient();
  80
  81   // Sends a text-check request to the Spelling service. When we send a request
  82   // to the Spelling service successfully, this function returns true. (This
  83   // does not mean the service finishes checking text successfully.) We will
  84   // call |callback| when we receive a text-check response from the service.
  85   bool RequestTextCheck(content::BrowserContext* context,
  86                         ServiceType type,
  87                         const string16& text,
  88                         const TextCheckCompleteCallback& callback);
  89
  90   // Returns whether the specified service is available for the given context.
  91   static bool IsAvailable(content::BrowserContext* context, ServiceType type);
  92
  93  protected:
  94   // Parses a JSON-RPC response from the Spelling service.
  95   bool ParseResponse(const std::string& data,
  96                      std::vector<SpellCheckResult>* results);
  97
  98  private:
  99   struct TextCheckCallbackData {
 100     TextCheckCallbackData(TextCheckCompleteCallback callback, string16 text);
 101     ~TextCheckCallbackData();
 102
 103     // The callback function to be called when we receive a response from the
 104     // Spelling service and parse it.
 105     TextCheckCompleteCallback callback;
 106
 107     // The text checked by the Spelling service.
 108     string16 text;
 109   };
 110
 111   // net::URLFetcherDelegate implementation.
 112   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 113
 114   // Creates a URLFetcher object used for sending a JSON-RPC request. This
 115   // function is overridden by unit tests to prevent them from actually sending
 116   // requests to the Spelling service.
 117   virtual net::URLFetcher* CreateURLFetcher(const GURL& url);
 118
 119   // The URLFetcher object used for sending a JSON-RPC request.
 120   std::map<const net::URLFetcher*, TextCheckCallbackData*> spellcheck_fetchers_;
 121 };
 122
 123 #endif  // CHROME_BROWSER_SPELLCHECKER_SPELLING_SERVICE_CLIENT_H_