Home | History | Annotate | Download | only in spellchecker 
      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 base::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 base::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 base::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,
    101                           base::string16 text);
    102     ~TextCheckCallbackData();
    103 
    104     // The callback function to be called when we receive a response from the
    105     // Spelling service and parse it.
    106     TextCheckCompleteCallback callback;
    107 
    108     // The text checked by the Spelling service.
    109     base::string16 text;
    110   };
    111 
    112   // net::URLFetcherDelegate implementation.
    113   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
    114 
    115   // Creates a URLFetcher object used for sending a JSON-RPC request. This
    116   // function is overridden by unit tests to prevent them from actually sending
    117   // requests to the Spelling service.
    118   virtual net::URLFetcher* CreateURLFetcher(const GURL& url);
    119 
    120   // The URLFetcher object used for sending a JSON-RPC request.
    121   std::map<const net::URLFetcher*, TextCheckCallbackData*> spellcheck_fetchers_;
    122 };
    123 
    124 #endif  // CHROME_BROWSER_SPELLCHECKER_SPELLING_SERVICE_CLIENT_H_
    125