1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
// Copyright 2017 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.
#ifndef CHROME_BROWSER_SPELLCHECKER_SPELL_CHECK_HOST_CHROME_IMPL_H_
#define CHROME_BROWSER_SPELLCHECKER_SPELL_CHECK_HOST_CHROME_IMPL_H_
#include "base/callback.h"
#include "base/containers/unique_ptr_adapters.h"
#include "build/build_config.h"
#include "build/chromeos_buildflags.h"
#include "components/spellcheck/browser/spell_check_host_impl.h"
#include "components/spellcheck/spellcheck_buildflags.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#if BUILDFLAG(ENABLE_SPELLING_SERVICE)
#include "components/spellcheck/browser/spelling_service_client.h"
#endif
class SpellcheckCustomDictionary;
class SpellcheckService;
class SpellingRequest;
struct SpellCheckResult;
// Implementation of SpellCheckHost involving Chrome-only features.
class SpellCheckHostChromeImpl : public SpellCheckHostImpl {
public:
explicit SpellCheckHostChromeImpl(int render_process_id);
SpellCheckHostChromeImpl(const SpellCheckHostChromeImpl&) = delete;
SpellCheckHostChromeImpl& operator=(const SpellCheckHostChromeImpl&) = delete;
~SpellCheckHostChromeImpl() override;
static void Create(
int render_process_id,
mojo::PendingReceiver<spellcheck::mojom::SpellCheckHost> receiver);
// Allows tests to override how |Create()| is implemented to bind a process
// hosts's SpellCheckHost receiver.
using Binder = base::RepeatingCallback<void(
int /* render_process_id */,
mojo::PendingReceiver<spellcheck::mojom::SpellCheckHost>)>;
static void OverrideBinderForTesting(Binder binder);
private:
friend class TestSpellCheckHostChromeImpl;
friend class SpellCheckHostChromeImplMacTest;
// SpellCheckHostImpl:
void RequestDictionary() override;
void NotifyChecked(const std::u16string& word, bool misspelled) override;
#if BUILDFLAG(USE_RENDERER_SPELLCHECKER)
void CallSpellingService(const std::u16string& text,
CallSpellingServiceCallback callback) override;
// Invoked when the remote Spelling service has finished checking the
// text of a CallSpellingService request.
void CallSpellingServiceDone(
CallSpellingServiceCallback callback,
bool success,
const std::u16string& text,
const std::vector<SpellCheckResult>& service_results) const;
// Filter out spelling corrections of custom dictionary words from the
// Spelling service results.
static std::vector<SpellCheckResult> FilterCustomWordResults(
const std::string& text,
const SpellcheckCustomDictionary& custom_dictionary,
const std::vector<SpellCheckResult>& service_results);
#endif
#if BUILDFLAG(USE_BROWSER_SPELLCHECKER) && BUILDFLAG(ENABLE_SPELLING_SERVICE)
// Implementations of the following APIs for build configs that don't use the
// spelling service are in the base class SpellCheckHostImpl.
void CheckSpelling(const std::u16string& word,
int route_id,
CheckSpellingCallback callback) override;
void FillSuggestionList(const std::u16string& word,
FillSuggestionListCallback callback) override;
void RequestTextCheck(const std::u16string& text,
int route_id,
RequestTextCheckCallback callback) override;
#if defined(OS_WIN)
void InitializeDictionaries(InitializeDictionariesCallback callback) override;
#endif // defined(OS_WIN)
// Clears a finished request from |requests_|. Exposed to SpellingRequest.
void OnRequestFinished(SpellingRequest* request);
// Exposed to tests only.
static void CombineResultsForTesting(
std::vector<SpellCheckResult>* remote_results,
const std::vector<SpellCheckResult>& local_results);
#if defined(OS_WIN)
void OnDictionariesInitialized();
// Callback passed as argument to InitializeDictionaries, and invoked when
// the dictionaries are loaded for the first time.
InitializeDictionariesCallback dictionaries_loaded_callback_;
#endif // defined(OS_WIN)
// All pending requests.
std::set<std::unique_ptr<SpellingRequest>, base::UniquePtrComparator>
requests_;
#endif // BUILDFLAG(USE_BROWSER_SPELLCHECKER) &&
// BUILDFLAG(ENABLE_SPELLING_SERVICE)
#if defined(OS_MAC)
int ToDocumentTag(int route_id);
void RetireDocumentTag(int route_id);
std::map<int, int> tag_map_;
#endif // defined(OS_MAC)
// Returns the SpellcheckService of our |render_process_id_|. The return
// is null if the render process is being shut down.
virtual SpellcheckService* GetSpellcheckService() const;
// The process ID of the renderer.
const int render_process_id_;
#if BUILDFLAG(ENABLE_SPELLING_SERVICE)
// A JSON-RPC client that calls the remote Spelling service.
SpellingServiceClient client_;
#endif
#if BUILDFLAG(USE_RENDERER_SPELLCHECKER)
base::WeakPtrFactory<SpellCheckHostChromeImpl> weak_factory_{this};
#endif
};
#endif // CHROME_BROWSER_SPELLCHECKER_SPELL_CHECK_HOST_CHROME_IMPL_H_
|
