path: root/chrome/browser/tab_contents/spelling_menu_observer.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 "chrome/browser/tab_contents/spelling_menu_observer.h"

#include <string>

#include "base/json/json_reader.h"
#include "base/json/string_escape.h"
#include "base/stringprintf.h"
#include "base/utf_string_conversions.h"
#include "base/values.h"
#include "chrome/app/chrome_command_ids.h"
#include "chrome/browser/prefs/pref_service.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/tab_contents/render_view_context_menu.h"
#include "chrome/common/pref_names.h"
#include "content/browser/renderer_host/render_view_host.h"
#include "content/public/common/url_fetcher.h"
#include "googleurl/src/gurl.h"
#include "grit/generated_resources.h"
#include "ui/base/l10n/l10n_util.h"
#include "unicode/uloc.h"
#include "webkit/glue/context_menu.h"

#if defined(GOOGLE_CHROME_BUILD)
#include "chrome/browser/spellchecker/internal/spellcheck_internal.h"
#else
// Use a dummy URL and a key on Chromium to avoid build breaks until the
// Spelling API is released. These dummy parameters just cause a timeout and
// show 'no suggestions found'.
#define SPELLING_SERVICE_KEY
#define SPELLING_SERVICE_URL "http://127.0.0.1/rpc"
#endif

SpellingMenuObserver::SpellingMenuObserver(RenderViewContextMenuProxy* proxy)
    : proxy_(proxy),
      loading_frame_(0),
      succeeded_(false) {
}

SpellingMenuObserver::~SpellingMenuObserver() {
}

void SpellingMenuObserver::InitMenu(const ContextMenuParams& params) {
  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

  // Exit if we are not in an editable element because we add a menu item only
  // for editable elements.
  if (!params.is_editable)
    return;

  Profile* profile = proxy_->GetProfile();
  if (!profile || !profile->GetRequestContext())
    return;

  // Retrieve the misspelled word to be sent to the Spelling service.
  string16 text = params.misspelled_word;
  if (text.empty())
    return;

  // Initialize variables used in OnURLFetchComplete(). We copy the input text
  // to the result text so we can replace its misspelled regions with
  // suggestions.
  loading_frame_ = 0;
  succeeded_ = false;
  result_ = text;

  // Add a placeholder item. This item will be updated when we receive a
  // response from the Spelling service. (We do not have to disable this item
  // now since Chrome will call IsCommandIdEnabled() and disable it.)
  loading_message_ =
      l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_SPELLING_CHECKING);
  proxy_->AddMenuItem(IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION,
                      loading_message_);

  // Invoke a JSON-RPC call to the Spelling service in the background so we can
  // update the placeholder item when we receive its response. It also starts
  // the animation timer so we can show animation until we receive it.
  const PrefService* pref = profile->GetPrefs();
  std::string language =
      pref ? pref->GetString(prefs::kSpellCheckDictionary) : "en-US";
  Invoke(text, language, profile->GetRequestContext());
}

bool SpellingMenuObserver::IsCommandIdSupported(int command_id) {
  return command_id == IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION;
}

bool SpellingMenuObserver::IsCommandIdEnabled(int command_id) {
  return command_id == IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION && succeeded_;
}

void SpellingMenuObserver::ExecuteCommand(int command_id) {
  if (IsCommandIdEnabled(command_id))
    proxy_->GetRenderViewHost()->Replace(result_);
}

bool SpellingMenuObserver::Invoke(const string16& text,
                                  const std::string& locale,
                                  net::URLRequestContextGetter* context) {
  // Create the parameters needed by Spelling API. Spelling API needs three
  // parameters: ISO language code, ISO3 country code, and text to be checked by
  // the service. On the other hand, Chrome uses an ISO locale ID and it may
  // not include a country ID, e.g. "fr", "de", etc. To create the input
  // parameters, we convert the UI locale to a full locale ID, and  convert the
  // full locale ID to an ISO language code and and ISO3 country code. Also, we
  // convert the given text to a JSON string, i.e. quote all its non-ASCII
  // characters.
  UErrorCode error = U_ZERO_ERROR;
  char id[ULOC_LANG_CAPACITY + ULOC_SCRIPT_CAPACITY + ULOC_COUNTRY_CAPACITY];
  uloc_addLikelySubtags(locale.c_str(), id, arraysize(id), &error);

  error = U_ZERO_ERROR;
  char language[ULOC_LANG_CAPACITY];
  uloc_getLanguage(id, language, arraysize(language), &error);

  const char* country = uloc_getISO3Country(id);

  std::string encoded_text;
  base::JsonDoubleQuote(text, false, &encoded_text);

  // Format the JSON request to be sent to the Spelling service.
  static const char kSpellingRequest[] =
      "{"
      "\"method\":\"spelling.check\","
      "\"apiVersion\":\"v1\","
      "\"params\":{"
      "\"text\":\"%s\","
      "\"language\":\"%s\","
      "\"origin_country\":\"%s\","
      "\"key\":\"" SPELLING_SERVICE_KEY "\""
      "}"
      "}";
  std::string request = base::StringPrintf(kSpellingRequest,
                                           encoded_text.c_str(),
                                           language, country);

  static const char kSpellingServiceURL[] = SPELLING_SERVICE_URL;
  GURL url = GURL(kSpellingServiceURL);
  fetcher_.reset(content::URLFetcher::Create(
      url, content::URLFetcher::POST, this));
  fetcher_->SetRequestContext(context);
  fetcher_->SetUploadData("application/json", request);
  fetcher_->Start();

  animation_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1),
      this, &SpellingMenuObserver::OnAnimationTimerExpired);

  return true;
}

void SpellingMenuObserver::OnURLFetchComplete(
    const content::URLFetcher* source) {
  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

  scoped_ptr<content::URLFetcher> clean_up_fetcher(fetcher_.release());
  animation_timer_.Stop();

  // Parse the response JSON and replace misspelled words in the |result_| text
  // with their suggestions.
  std::string data;
  source->GetResponseAsString(&data);
  succeeded_ = ParseResponse(source->GetResponseCode(), data);
  if (!succeeded_)
    result_ = l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_SPELLING_CORRECT);

  // Update the menu item with the result text. We enable this item only when
  // the request text has misspelled words. (We disable this item not only when
  // we receive a server error but also when the input text consists only of
  // well-spelled words. For either case, we do not need to replace the input
  // text.)
  proxy_->UpdateMenuItem(IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION, succeeded_,
                         false, result_);
}

bool SpellingMenuObserver::ParseResponse(int response,
                                         const std::string& data) {
  // When this JSON-RPC call finishes successfully, the Spelling service returns
  // an JSON object listed below.
  // * result - an envelope object representing the result from the APIARY
  //   server, which is the JSON-API front-end for the Spelling service. This
  //   object consists of the following variable:
  //   - spellingCheckResponse (SpellingCheckResponse).
  // * SpellingCheckResponse - an object representing the result from the
  //   Spelling service. This object consists of the following variable:
  //   - misspellings (optional array of Misspelling)
  // * Misspelling - an object representing a misspelling region and its
  //   suggestions. This object consists of the following variables:
  //   - charStart (number) - the beginning of the misspelled region;
  //   - charLength (number) - the length of the misspelled region;
  //   - suggestions (array of string) - the suggestions for the misspelling
  //     text, and;
  //   - canAutoCorrect (optional boolean) - whether we can use the first
  //     suggestion for auto-correction.
  // For example, the Spelling service returns the following JSON when we send a
  // spelling request for "duck goes quisk" as of 16 August, 2011.
  // {
  //   "result": {
  //   "spellingCheckResponse": {
  //     "misspellings": [{
  //         "charStart": 10,
  //         "charLength": 5,
  //         "suggestions": [{ "suggestion": "quack" }],
  //         "canAutoCorrect": false
  //     }]
  //   }
  // }

  // When a server error happened in the APIARY server (including when we cannot
  // get any responses from the server), it returns an HTTP error.
  if ((response / 100) != 2)
    return false;

  scoped_ptr<DictionaryValue> value(
      static_cast<DictionaryValue*>(base::JSONReader::Read(data, true)));
  if (!value.get() || !value->IsType(base::Value::TYPE_DICTIONARY))
    return false;

  // Retrieve the array of Misspelling objects. When the APIARY service failed
  // calling the Spelling service, it returns a JSON representing the service
  // error. (In this case, its HTTP status is 200.) We just return false for
  // this case.
  ListValue* misspellings = NULL;
  const char kMisspellings[] = "result.spellingCheckResponse.misspellings";
  if (!value->GetList(kMisspellings, &misspellings))
    return false;

  // For each misspelled region, we replace it with its first suggestion.
  for (size_t i = 0; i < misspellings->GetSize(); ++i) {
    // Retrieve the i-th misspelling region, which represents misspelling text
    // in the request text and its alternative.
    DictionaryValue* misspelling = NULL;
    if (!misspellings->GetDictionary(i, &misspelling))
      return false;

    int start = 0;
    int length = 0;
    ListValue* suggestions = NULL;
    if (!misspelling->GetInteger("charStart", &start) ||
        !misspelling->GetInteger("charLength", &length) ||
        !misspelling->GetList("suggestions", &suggestions)) {
      return false;
    }

    // Retrieve the alternative text and replace the misspelling region with the
    // alternative.
    DictionaryValue* suggestion = NULL;
    string16 text;
    if (!suggestions->GetDictionary(0, &suggestion) ||
        !suggestion->GetString("suggestion", &text)) {
      return false;
    }
    result_.replace(start, length, text);
  }

  return true;
}

void SpellingMenuObserver::OnAnimationTimerExpired() {
  if (!fetcher_.get())
    return;

  // Append '.' characters to the end of "Checking".
  loading_frame_ = (loading_frame_ + 1) & 3;
  string16 loading_message = loading_message_;
  for (int i = 0; i < loading_frame_; ++i)
    loading_message.push_back('.');

  // Update the menu item with the text. We disable this item to prevent users
  // from selecting it.
  proxy_->UpdateMenuItem(IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION, false, false,
                         loading_message);
}