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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
// Copyright (c) 2012 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_TRANSLATE_TRANSLATE_MANAGER_H_
#define CHROME_BROWSER_TRANSLATE_TRANSLATE_MANAGER_H_
#include <map>
#include <string>
#include <vector>
#include "base/gtest_prod_util.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "content/public/browser/notification_observer.h"
#include "content/public/browser/notification_registrar.h"
template <typename T> struct DefaultSingletonTraits;
class GURL;
struct LanguageDetectionDetails;
struct PageTranslatedDetails;
class PrefService;
class Profile;
struct TranslateErrorDetails;
namespace content {
class WebContents;
}
namespace net {
class URLFetcher;
}
// The TranslateManager class is responsible for showing an info-bar when a page
// in a language different than the user language is loaded. It triggers the
// page translation the user requests.
// It is a singleton.
class TranslateManager : public content::NotificationObserver {
public:
// Returns the singleton instance.
static TranslateManager* GetInstance();
virtual ~TranslateManager();
// Returns true if the URL can be translated.
static bool IsTranslatableURL(const GURL& url);
// Returns the language to translate to. The language returned is the
// first language found in the following list that is supported by the
// translation service:
// the UI language
// the accept-language list
// If no language is found then an empty string is returned.
static std::string GetTargetLanguage(PrefService* prefs);
// Returns the language to automatically translate to. |original_language| is
// the webpage's original language.
static std::string GetAutoTargetLanguage(const std::string& original_language,
PrefService* prefs);
// Translates the page contents from |source_lang| to |target_lang|.
// The actual translation might be performed asynchronously if the translate
// script is not yet available.
void TranslatePage(content::WebContents* web_contents,
const std::string& source_lang,
const std::string& target_lang);
// Reverts the contents of the page in |web_contents| to its original
// language.
void RevertTranslation(content::WebContents* web_contents);
// Reports to the Google translate server that a page language was incorrectly
// detected. This call is initiated by the user selecting the "report" menu
// under options in the translate infobar.
void ReportLanguageDetectionError(content::WebContents* web_contents);
// content::NotificationObserver implementation:
virtual void Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) OVERRIDE;
// Number of attempts before waiting for a page to be fully reloaded.
void set_translate_max_reload_attemps(int attempts) {
max_reload_check_attempts_ = attempts;
}
// The observer class for TranslateManager.
class Observer {
public:
virtual void OnLanguageDetection(
const LanguageDetectionDetails& details) = 0;
virtual void OnTranslateError(
const TranslateErrorDetails& details) = 0;
};
// Adds/removes observer.
void AddObserver(Observer* obs);
void RemoveObserver(Observer* obs);
protected:
TranslateManager();
private:
friend struct DefaultSingletonTraits<TranslateManager>;
// Structure that describes a translate request.
// Translation may be deferred while the translate script is being retrieved
// from the translate server.
struct PendingRequest {
int render_process_id;
int render_view_id;
int page_id;
std::string source_lang;
std::string target_lang;
};
// Starts the translation process on |tab| containing the page in the
// |page_lang| language.
void InitiateTranslation(content::WebContents* web_contents,
const std::string& page_lang);
// If the tab identified by |process_id| and |render_id| has been closed, this
// does nothing, otherwise it calls InitiateTranslation.
void InitiateTranslationPosted(int process_id, int render_id,
const std::string& page_lang, int attempt);
// Sends a translation request to the RenderView of |web_contents|.
void DoTranslatePage(content::WebContents* web_contents,
const std::string& translate_script,
const std::string& source_lang,
const std::string& target_lang);
// Shows the after translate or error infobar depending on the details.
void PageTranslated(content::WebContents* web_contents,
PageTranslatedDetails* details);
void OnTranslateScriptFetchComplete(bool success, const std::string& data);
// Notifies to the observers when a language is detected.
void NotifyLanguageDetection(const LanguageDetectionDetails& details);
// Notifies to the observers when translate failed.
void NotifyTranslateError(const TranslateErrorDetails& details);
content::NotificationRegistrar notification_registrar_;
// Max number of attempts before checking if a page has been reloaded.
int max_reload_check_attempts_;
// The list of pending translate requests. Translate requests are queued when
// the translate script is not ready and has to be fetched from the translate
// server.
std::vector<PendingRequest> pending_requests_;
// List of registered observers.
ObserverList<Observer> observer_list_;
base::WeakPtrFactory<TranslateManager> weak_method_factory_;
DISALLOW_COPY_AND_ASSIGN(TranslateManager);
};
#endif // CHROME_BROWSER_TRANSLATE_TRANSLATE_MANAGER_H_
|
