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
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ui/webui/version/version_handler.h"
#include <stddef.h>
#include <string>
#include "base/base64.h"
#include "base/command_line.h"
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/metrics/field_trial.h"
#include "base/task/thread_pool.h"
#include "base/threading/scoped_blocking_call.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/grit/generated_resources.h"
#include "components/strings/grit/components_strings.h"
#include "components/variations/active_field_trials.h"
#include "components/variations/net/variations_command_line.h"
#include "components/webui/version/version_handler_helper.h"
#include "components/webui/version/version_ui_constants.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/web_contents.h"
#include "content/public/browser/web_ui.h"
#include "content/public/browser/web_ui_message_handler.h"
#include "ui/base/l10n/l10n_util.h"
#include "url/gurl.h"
namespace {
// Retrieves the executable and profile paths on the FILE thread.
void GetFilePaths(const base::FilePath& profile_path,
std::u16string* exec_path_out,
std::u16string* profile_path_out) {
base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
base::BlockingType::MAY_BLOCK);
base::FilePath executable_path = base::MakeAbsoluteFilePath(
base::CommandLine::ForCurrentProcess()->GetProgram());
if (!executable_path.empty()) {
*exec_path_out = executable_path.LossyDisplayName();
} else {
*exec_path_out = l10n_util::GetStringUTF16(IDS_VERSION_UI_PATH_NOTFOUND);
}
base::FilePath profile_path_copy(base::MakeAbsoluteFilePath(profile_path));
if (!profile_path.empty() && !profile_path_copy.empty()) {
*profile_path_out = profile_path.LossyDisplayName();
} else {
*profile_path_out = l10n_util::GetStringUTF16(IDS_VERSION_UI_PATH_NOTFOUND);
}
}
} // namespace
VersionHandler::VersionHandler() = default;
VersionHandler::~VersionHandler() = default;
void VersionHandler::OnJavascriptDisallowed() {
weak_ptr_factory_.InvalidateWeakPtrs();
}
void VersionHandler::RegisterMessages() {
web_ui()->RegisterMessageCallback(
version_ui::kRequestVersionInfo,
base::BindRepeating(&VersionHandler::HandleRequestVersionInfo,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
version_ui::kRequestVariationInfo,
base::BindRepeating(&VersionHandler::HandleRequestVariationInfo,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
version_ui::kRequestPathInfo,
base::BindRepeating(&VersionHandler::HandleRequestPathInfo,
base::Unretained(this)));
}
void VersionHandler::HandleRequestVersionInfo(const base::Value::List& args) {
// This method is overridden by platform-specific handlers which may still
// use |CallJavascriptFunction|. Main version info is returned by promise
// using handlers below.
// TODO(orinj): To fully eliminate chrome.send usage in JS, derived classes
// could be made to work more like this base class, using
// |ResolveJavascriptCallback| instead of |CallJavascriptFunction|.
AllowJavascript();
}
void VersionHandler::HandleRequestVariationInfo(const base::Value::List& args) {
AllowJavascript();
CHECK_EQ(2U, args.size());
const std::string& callback_id = args[0].GetString();
const bool return_raw_variations_cmd = args[1].GetBool();
base::Value::Dict response;
response.Set(version_ui::kKeyVariationsList, version_ui::GetVariationsList());
if (return_raw_variations_cmd) {
response.Set(version_ui::kKeyVariationsCmd,
version_ui::GetVariationsCommandLine());
} else {
std::string content;
bool success =
variations::VariationsCommandLine::GetForCurrentProcess().WriteToString(
&content);
if (success) {
response.Set(version_ui::kKeyVariationsCmd, base::Base64Encode(content));
}
}
ResolveJavascriptCallback(base::Value(callback_id), response);
}
void VersionHandler::HandleRequestPathInfo(const base::Value::List& args) {
AllowJavascript();
CHECK_EQ(1U, args.size());
const std::string& callback_id = args[0].GetString();
// Grab the executable path on the FILE thread. It is returned in
// OnGotFilePaths.
std::u16string* exec_path_buffer = new std::u16string;
std::u16string* profile_path_buffer = new std::u16string;
base::ThreadPool::PostTaskAndReply(
FROM_HERE, {base::TaskPriority::USER_VISIBLE, base::MayBlock()},
base::BindOnce(&GetFilePaths, Profile::FromWebUI(web_ui())->GetPath(),
base::Unretained(exec_path_buffer),
base::Unretained(profile_path_buffer)),
base::BindOnce(&VersionHandler::OnGotFilePaths,
weak_ptr_factory_.GetWeakPtr(), callback_id,
base::Owned(exec_path_buffer),
base::Owned(profile_path_buffer)));
}
void VersionHandler::OnGotFilePaths(std::string callback_id,
std::u16string* executable_path_data,
std::u16string* profile_path_data) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
base::Value::Dict response;
response.Set(version_ui::kKeyExecPath, *executable_path_data);
response.Set(version_ui::kKeyProfilePath, *profile_path_data);
ResolveJavascriptCallback(base::Value(callback_id), response);
}
|
