mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Merge pull request #12649 from electron/clang-format-brightray

Browse source 
clang-format brightray
This commit is contained in:
Shelley Vohr 2018-04-18 22:59:04 -04:00 committed by GitHub
commit c090dd2f81
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
61 changed files with 1547 additions and 1684 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
brightray/browser/brightray_paths.h
View file

@ -21,8 +21,8 @@ enum {
PATH_START = 11000,
DIR_USER_DATA = PATH_START, // Directory where user data can be written.
DIR_USER_CACHE, // Directory where user cache can be written.
DIR_APP_LOGS, // Directory where app logs live
DIR_USER_CACHE, // Directory where user cache can be written.
DIR_APP_LOGS, // Directory where app logs live
#if defined(OS_LINUX)
DIR_APP_DATA, // Application Data directory under the user profile.

6
brightray/browser/browser_client.cc
View file

@ -51,14 +51,12 @@ BrowserClient* BrowserClient::Get() {
return g_browser_client;
}
BrowserClient::BrowserClient()
: browser_main_parts_(nullptr) {
BrowserClient::BrowserClient() : browser_main_parts_(nullptr) {
DCHECK(!g_browser_client);
g_browser_client = this;
}
BrowserClient::~BrowserClient() {
}
BrowserClient::~BrowserClient() {}
NotificationPresenter* BrowserClient::GetNotificationPresenter() {
if (!notification_presenter_) {

20
brightray/browser/browser_context.cc
View file

@ -61,8 +61,8 @@ class BrowserContext::ResourceContext : public content::ResourceContext {
BrowserContext::BrowserContextMap BrowserContext::browser_context_map_;
// static
scoped_refptr<BrowserContext> BrowserContext::Get(
const std::string& partition, bool in_memory) {
scoped_refptr<BrowserContext> BrowserContext::Get(const std::string& partition,
bool in_memory) {
PartitionKey key(partition, in_memory);
if (browser_context_map_[key].get())
return WrapRefCounted(browser_context_map_[key].get());
@ -137,13 +137,9 @@ net::URLRequestContextGetter* BrowserContext::CreateRequestContext(
content::URLRequestInterceptorScopedVector protocol_interceptors) {
DCHECK(!url_request_getter_.get());
url_request_getter_ = new URLRequestContextGetter(
this,
static_cast<NetLog*>(BrowserClient::Get()->GetNetLog()),
GetPath(),
in_memory_,
BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
protocol_handlers,
std::move(protocol_interceptors));
this, static_cast<NetLog*>(BrowserClient::Get()->GetNetLog()), GetPath(),
in_memory_, BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
protocol_handlers, std::move(protocol_interceptors));
resource_context_->set_url_request_context_getter(url_request_getter_.get());
return url_request_getter_.get();
}
@ -204,8 +200,7 @@ content::PermissionManager* BrowserContext::GetPermissionManager() {
return permission_manager_.get();
}
content::BackgroundFetchDelegate*
BrowserContext::GetBackgroundFetchDelegate() {
content::BackgroundFetchDelegate* BrowserContext::GetBackgroundFetchDelegate() {
return nullptr;
}
@ -228,8 +223,7 @@ BrowserContext::CreateRequestContextForStoragePartition(
return nullptr;
}
net::URLRequestContextGetter*
BrowserContext::CreateMediaRequestContext() {
net::URLRequestContextGetter* BrowserContext::CreateMediaRequestContext() {
return url_request_getter_.get();
}

4
brightray/browser/browser_context.h
View file

@ -32,8 +32,8 @@ class BrowserContext : public base::RefCounted<BrowserContext>,
public:
// Get the BrowserContext according to its |partition| and |in_memory|,
// empty pointer when be returned when there is no matching BrowserContext.
static scoped_refptr<BrowserContext> Get(
const std::string& partition, bool in_memory);
static scoped_refptr<BrowserContext> Get(const std::string& partition,
bool in_memory);
base::WeakPtr<BrowserContext> GetWeakPtr() {
return weak_factory_.GetWeakPtr();

13
brightray/browser/browser_main_parts.cc
View file

@ -98,8 +98,7 @@ void OverrideLinuxAppDataPath() {
if (PathService::Get(DIR_APP_DATA, &path))
return;
std::unique_ptr<base::Environment> env(base::Environment::Create());
path = base::nix::GetXDGDirectory(env.get(),
base::nix::kXdgConfigHomeEnvVar,
path = base::nix::GetXDGDirectory(env.get(), base::nix::kXdgConfigHomeEnvVar,
base::nix::kDotConfigDir);
PathService::Override(DIR_APP_DATA, path);
}
@ -167,11 +166,9 @@ base::string16 MediaStringProvider(media::MessageId id) {
} // namespace
BrowserMainParts::BrowserMainParts() {
}
BrowserMainParts::BrowserMainParts() {}
BrowserMainParts::~BrowserMainParts() {
}
BrowserMainParts::~BrowserMainParts() {}
#if defined(OS_WIN) || defined(OS_LINUX)
void OverrideAppLogsPath() {
@ -220,7 +217,7 @@ void BrowserMainParts::ToolkitInitialized() {
gfx::PlatformFontWin::adjust_font_callback = &AdjustUIFont;
gfx::PlatformFontWin::get_minimum_font_size_callback = &GetMinimumFontSize;
wchar_t module_name[MAX_PATH] = { 0 };
wchar_t module_name[MAX_PATH] = {0};
if (GetModuleFileName(NULL, module_name, MAX_PATH))
ui::CursorLoaderWin::SetCursorResourceModule(module_name);
#endif
@ -304,7 +301,7 @@ int BrowserMainParts::PreCreateThreads() {
// Initialize the app locale.
BrowserClient::SetApplicationLocale(
l10n_util::GetApplicationLocale(custom_locale_));
l10n_util::GetApplicationLocale(custom_locale_));
// Manage global state of net and other IO thread related.
io_thread_ = std::make_unique<IOThread>();

16
brightray/browser/devtools_contents_resizing_strategy.cc
View file

@ -7,15 +7,13 @@
#include <algorithm>
DevToolsContentsResizingStrategy::DevToolsContentsResizingStrategy()
: hide_inspected_contents_(false) {
}
: hide_inspected_contents_(false) {}
DevToolsContentsResizingStrategy::DevToolsContentsResizingStrategy(
const gfx::Rect& bounds)
: bounds_(bounds),
hide_inspected_contents_(bounds_.IsEmpty() && !bounds_.x() &&
!bounds_.y()) {
}
!bounds_.y()) {}
void DevToolsContentsResizingStrategy::CopyFrom(
const DevToolsContentsResizingStrategy& strategy) {
@ -26,7 +24,7 @@ void DevToolsContentsResizingStrategy::CopyFrom(
bool DevToolsContentsResizingStrategy::Equals(
const DevToolsContentsResizingStrategy& strategy) {
return bounds_ == strategy.bounds() &&
hide_inspected_contents_ == strategy.hide_inspected_contents();
hide_inspected_contents_ == strategy.hide_inspected_contents();
}
void ApplyDevToolsContentsResizingStrategy(
@ -34,13 +32,13 @@ void ApplyDevToolsContentsResizingStrategy(
const gfx::Size& container_size,
gfx::Rect* new_devtools_bounds,
gfx::Rect* new_contents_bounds) {
new_devtools_bounds->SetRect(
0, 0, container_size.width(), container_size.height());
new_devtools_bounds->SetRect(0, 0, container_size.width(),
container_size.height());
const gfx::Rect& bounds = strategy.bounds();
if (bounds.size().IsEmpty() && !strategy.hide_inspected_contents()) {
new_contents_bounds->SetRect(
0, 0, container_size.width(), container_size.height());
new_contents_bounds->SetRect(0, 0, container_size.width(),
container_size.height());
return;
}

3
brightray/browser/devtools_contents_resizing_strategy.h
View file

@ -14,8 +14,7 @@
class DevToolsContentsResizingStrategy {
public:
DevToolsContentsResizingStrategy();
explicit DevToolsContentsResizingStrategy(
const gfx::Rect& bounds);
explicit DevToolsContentsResizingStrategy(const gfx::Rect& bounds);
void CopyFrom(const DevToolsContentsResizingStrategy& strategy);
bool Equals(const DevToolsContentsResizingStrategy& strategy);

50
brightray/browser/devtools_embedder_message_dispatcher.cc
View file

@ -33,8 +33,7 @@ bool GetValue(const base::Value& value, gfx::Rect* rect) {
int y = 0;
int width = 0;
int height = 0;
if (!dict->GetInteger("x", &x) ||
!dict->GetInteger("y", &y) ||
if (!dict->GetInteger("x", &x) || !dict->GetInteger("y", &y) ||
!dict->GetInteger("width", &width) ||
!dict->GetInteger("height", &height))
return false;
@ -69,8 +68,7 @@ template <typename T, typename... Ts>
struct ParamTuple<T, Ts...> {
bool Parse(const base::ListValue& list,
const base::ListValue::const_iterator& it) {
return it != list.end() && GetValue(*it, &head) &&
tail.Parse(list, it + 1);
return it != list.end() && GetValue(*it, &head) && tail.Parse(list, it + 1);
}
template <typename H, typename... As>
@ -82,7 +80,7 @@ struct ParamTuple<T, Ts...> {
ParamTuple<Ts...> tail;
};
template<typename... As>
template <typename... As>
bool ParseAndHandle(const base::Callback<void(As...)>& handler,
const DispatchCallback& callback,
const base::ListValue& list) {
@ -93,7 +91,7 @@ bool ParseAndHandle(const base::Callback<void(As...)>& handler,
return true;
}
template<typename... As>
template <typename... As>
bool ParseAndHandleWithCallback(
const base::Callback<void(const DispatchCallback&, As...)>& handler,
const DispatchCallback& callback,
@ -126,28 +124,28 @@ class DispatcherImpl : public DevToolsEmbedderMessageDispatcher {
return it != handlers_.end() && it->second.Run(callback, *params);
}
template<typename... As>
template <typename... As>
void RegisterHandler(const std::string& method,
void (Delegate::*handler)(As...),
Delegate* delegate) {
handlers_[method] = base::Bind(&ParseAndHandle<As...>,
base::Bind(handler,
base::Unretained(delegate)));
handlers_[method] =
base::Bind(&ParseAndHandle<As...>,
base::Bind(handler, base::Unretained(delegate)));
}
template<typename... As>
template <typename... As>
void RegisterHandlerWithCallback(
const std::string& method,
void (Delegate::*handler)(const DispatchCallback&, As...),
Delegate* delegate) {
handlers_[method] = base::Bind(&ParseAndHandleWithCallback<As...>,
base::Bind(handler,
base::Unretained(delegate)));
handlers_[method] =
base::Bind(&ParseAndHandleWithCallback<As...>,
base::Bind(handler, base::Unretained(delegate)));
}
private:
using Handler = base::Callback<bool(const DispatchCallback&,
const base::ListValue&)>;
using Handler =
base::Callback<bool(const DispatchCallback&, const base::ListValue&)>;
using HandlerMap = std::map<std::string, Handler>;
HandlerMap handlers_;
};
@ -165,15 +163,15 @@ DevToolsEmbedderMessageDispatcher::CreateForDevToolsFrontend(
&Delegate::SetInspectedPageBounds, delegate);
d->RegisterHandler("inspectElementCompleted",
&Delegate::InspectElementCompleted, delegate);
d->RegisterHandler("inspectedURLChanged",
&Delegate::InspectedURLChanged, delegate);
d->RegisterHandlerWithCallback("setIsDocked",
&Delegate::SetIsDocked, delegate);
d->RegisterHandler("inspectedURLChanged", &Delegate::InspectedURLChanged,
delegate);
d->RegisterHandlerWithCallback("setIsDocked", &Delegate::SetIsDocked,
delegate);
d->RegisterHandler("openInNewTab", &Delegate::OpenInNewTab, delegate);
d->RegisterHandler("save", &Delegate::SaveToFile, delegate);
d->RegisterHandler("append", &Delegate::AppendToFile, delegate);
d->RegisterHandler("requestFileSystems",
&Delegate::RequestFileSystems, delegate);
d->RegisterHandler("requestFileSystems", &Delegate::RequestFileSystems,
delegate);
d->RegisterHandler("addFileSystem", &Delegate::AddFileSystem, delegate);
d->RegisterHandler("removeFileSystem", &Delegate::RemoveFileSystem, delegate);
d->RegisterHandler("upgradeDraggedFileSystemPermissions",
@ -193,10 +191,10 @@ DevToolsEmbedderMessageDispatcher::CreateForDevToolsFrontend(
d->RegisterHandler("dispatchProtocolMessage",
&Delegate::DispatchProtocolMessageFromDevToolsFrontend,
delegate);
d->RegisterHandlerWithCallback("sendJsonRequest",
&Delegate::SendJsonRequest, delegate);
d->RegisterHandlerWithCallback("getPreferences",
&Delegate::GetPreferences, delegate);
d->RegisterHandlerWithCallback("sendJsonRequest", &Delegate::SendJsonRequest,
delegate);
d->RegisterHandlerWithCallback("getPreferences", &Delegate::GetPreferences,
delegate);
d->RegisterHandler("setPreference", &Delegate::SetPreference, delegate);
d->RegisterHandler("removePreference", &Delegate::RemovePreference, delegate);
d->RegisterHandler("clearPreferences", &Delegate::ClearPreferences, delegate);

2
brightray/browser/devtools_embedder_message_dispatcher.h
View file

@ -16,7 +16,7 @@
namespace base {
class ListValue;
class Value;
}
} // namespace base
namespace brightray {

66
brightray/browser/devtools_file_system_indexer.cc
View file

@ -78,7 +78,7 @@ class Index {
FileIdsMap file_ids_;
FileId last_file_id_;
// The index in this vector is the trigram id.
vector<vector<FileId> > index_;
vector<vector<FileId>> index_;
typedef map<FilePath, Time> IndexedFilesMap;
IndexedFilesMap index_times_;
vector<bool> is_normalized_;
@ -175,10 +175,10 @@ vector<FilePath> Index::Search(string query) {
vector<TrigramChar> trigram_chars;
trigram_chars.reserve(query.size());
for (size_t i = 0; i < query.size(); ++i) {
TrigramChar trigram_char = TrigramCharForChar(data[i]);
if (trigram_char == kBinaryTrigramChar)
trigram_char = kUndefinedTrigramChar;
trigram_chars.push_back(trigram_char);
TrigramChar trigram_char = TrigramCharForChar(data[i]);
if (trigram_char == kBinaryTrigramChar)
trigram_char = kUndefinedTrigramChar;
trigram_chars.push_back(trigram_char);
}
vector<Trigram> trigrams;
for (size_t i = 0; i + 2 < query.size(); ++i) {
@ -192,21 +192,19 @@ vector<FilePath> Index::Search(string query) {
for (; it != trigrams.end(); ++it) {
Trigram trigram = *it;
if (first) {
std::copy(index_[trigram].begin(),
index_[trigram].end(),
std::copy(index_[trigram].begin(), index_[trigram].end(),
std::inserter(file_ids, file_ids.begin()));
first = false;
continue;
}
set<FileId> intersection = base::STLSetIntersection<set<FileId> >(
file_ids, index_[trigram]);
set<FileId> intersection =
base::STLSetIntersection<set<FileId>>(file_ids, index_[trigram]);
file_ids.swap(intersection);
}
vector<FilePath> result;
FileIdsMap::const_iterator ids_it = file_ids_.begin();
for (; ids_it != file_ids_.end(); ++ids_it) {
if (trigrams.empty() ||
file_ids.find(ids_it->second) != file_ids.end()) {
if (trigrams.empty() || file_ids.find(ids_it->second) != file_ids.end()) {
result.push_back(ids_it->first);
}
}
@ -280,15 +278,13 @@ DevToolsFileSystemIndexer::FileSystemIndexingJob::~FileSystemIndexingJob() {}
void DevToolsFileSystemIndexer::FileSystemIndexingJob::Start() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
BrowserThread::PostTask(
BrowserThread::FILE,
FROM_HERE,
BrowserThread::FILE, FROM_HERE,
Bind(&FileSystemIndexingJob::CollectFilesToIndex, this));
}
void DevToolsFileSystemIndexer::FileSystemIndexingJob::Stop() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
BrowserThread::PostTask(BrowserThread::FILE,
FROM_HERE,
BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
Bind(&FileSystemIndexingJob::StopOnFileThread, this));
}
@ -307,8 +303,7 @@ void DevToolsFileSystemIndexer::FileSystemIndexingJob::CollectFilesToIndex() {
FilePath file_path = file_enumerator_->Next();
if (file_path.empty()) {
BrowserThread::PostTask(
BrowserThread::UI,
FROM_HERE,
BrowserThread::UI, FROM_HERE,
Bind(total_work_callback_, file_path_times_.size()));
indexing_it_ = file_path_times_.begin();
IndexFiles();
@ -322,8 +317,7 @@ void DevToolsFileSystemIndexer::FileSystemIndexingJob::CollectFilesToIndex() {
file_path_times_[file_path] = current_last_modified_time;
}
BrowserThread::PostTask(
BrowserThread::FILE,
FROM_HERE,
BrowserThread::FILE, FROM_HERE,
Bind(&FileSystemIndexingJob::CollectFilesToIndex, this));
}
@ -338,9 +332,8 @@ void DevToolsFileSystemIndexer::FileSystemIndexingJob::IndexFiles() {
}
FilePath file_path = indexing_it_->first;
current_file_.CreateOrOpen(
file_path,
base::File::FLAG_OPEN | base::File::FLAG_READ,
Bind(&FileSystemIndexingJob::StartFileIndexing, this));
file_path, base::File::FLAG_OPEN | base::File::FLAG_READ,
Bind(&FileSystemIndexingJob::StartFileIndexing, this));
}
void DevToolsFileSystemIndexer::FileSystemIndexingJob::StartFileIndexing(
@ -408,8 +401,8 @@ void DevToolsFileSystemIndexer::FileSystemIndexingJob::FinishFileIndexing(
CloseFile();
if (success) {
FilePath file_path = indexing_it_->first;
g_trigram_index.Get().SetTrigramsForFile(
file_path, current_trigrams_, file_path_times_[file_path]);
g_trigram_index.Get().SetTrigramsForFile(file_path, current_trigrams_,
file_path_times_[file_path]);
}
ReportWorked();
++indexing_it_;
@ -435,14 +428,13 @@ void DevToolsFileSystemIndexer::FileSystemIndexingJob::ReportWorked() {
++files_indexed_;
if (should_send_worked_nitification) {
last_worked_notification_time_ = current_time;
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE, Bind(worked_callback_, files_indexed_));
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
Bind(worked_callback_, files_indexed_));
files_indexed_ = 0;
}
}
DevToolsFileSystemIndexer::DevToolsFileSystemIndexer() {
}
DevToolsFileSystemIndexer::DevToolsFileSystemIndexer() {}
DevToolsFileSystemIndexer::~DevToolsFileSystemIndexer() {}
@ -453,11 +445,9 @@ DevToolsFileSystemIndexer::IndexPath(
const WorkedCallback& worked_callback,
const DoneCallback& done_callback) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
scoped_refptr<FileSystemIndexingJob> indexing_job =
new FileSystemIndexingJob(FilePath::FromUTF8Unsafe(file_system_path),
total_work_callback,
worked_callback,
done_callback);
scoped_refptr<FileSystemIndexingJob> indexing_job = new FileSystemIndexingJob(
FilePath::FromUTF8Unsafe(file_system_path), total_work_callback,
worked_callback, done_callback);
indexing_job->Start();
return indexing_job;
}
@ -467,13 +457,9 @@ void DevToolsFileSystemIndexer::SearchInPath(const string& file_system_path,
const SearchCallback& callback) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
BrowserThread::PostTask(
BrowserThread::FILE,
FROM_HERE,
Bind(&DevToolsFileSystemIndexer::SearchInPathOnFileThread,
this,
file_system_path,
query,
callback));
BrowserThread::FILE, FROM_HERE,
Bind(&DevToolsFileSystemIndexer::SearchInPathOnFileThread, this,
file_system_path, query, callback));
}
void DevToolsFileSystemIndexer::SearchInPathOnFileThread(

6
brightray/browser/devtools_file_system_indexer.h
View file

@ -21,7 +21,7 @@ namespace base {
class FilePath;
class FileEnumerator;
class Time;
}
} // namespace base
namespace content {
class WebContents;
@ -56,9 +56,7 @@ class DevToolsFileSystemIndexer
void IndexFiles();
void StartFileIndexing(base::File::Error error);
void ReadFromFile();
void OnRead(base::File::Error error,
const char* data,
int bytes_read);
void OnRead(base::File::Error error, const char* data, int bytes_read);
void FinishFileIndexing(bool success);
void CloseFile();
void CloseCallback(base::File::Error error);

26
brightray/browser/devtools_manager_delegate.cc
View file

@ -34,8 +34,7 @@ namespace {
class TCPServerSocketFactory : public content::DevToolsSocketFactory {
public:
TCPServerSocketFactory(const std::string& address, int port)
: address_(address), port_(port) {
}
: address_(address), port_(port) {}
private:
// content::ServerSocketFactory.
@ -58,8 +57,7 @@ class TCPServerSocketFactory : public content::DevToolsSocketFactory {
DISALLOW_COPY_AND_ASSIGN(TCPServerSocketFactory);
};
std::unique_ptr<content::DevToolsSocketFactory>
CreateSocketFactory() {
std::unique_ptr<content::DevToolsSocketFactory> CreateSocketFactory() {
auto& command_line = *base::CommandLine::ForCurrentProcess();
// See if the user specified a port on the command line (useful for
// automation). If not, use an ephemeral port by specifying 0.
@ -68,8 +66,8 @@ CreateSocketFactory() {
int temp_port;
std::string port_str =
command_line.GetSwitchValueASCII(switches::kRemoteDebuggingPort);
if (base::StringToInt(port_str, &temp_port) &&
temp_port > 0 && temp_port < 65535) {
if (base::StringToInt(port_str, &temp_port) && temp_port > 0 &&
temp_port < 65535) {
port = temp_port;
} else {
DLOG(WARNING) << "Invalid http debugger port number " << temp_port;
@ -86,19 +84,14 @@ CreateSocketFactory() {
// static
void DevToolsManagerDelegate::StartHttpHandler() {
content::DevToolsAgentHost::StartRemoteDebuggingServer(
CreateSocketFactory(),
std::string(),
base::FilePath(),
base::FilePath());
CreateSocketFactory(), std::string(), base::FilePath(), base::FilePath());
}
DevToolsManagerDelegate::DevToolsManagerDelegate() {}
DevToolsManagerDelegate::~DevToolsManagerDelegate() {
}
DevToolsManagerDelegate::~DevToolsManagerDelegate() {}
void DevToolsManagerDelegate::Inspect(content::DevToolsAgentHost* agent_host) {
}
void DevToolsManagerDelegate::Inspect(content::DevToolsAgentHost* agent_host) {}
bool DevToolsManagerDelegate::HandleCommand(
content::DevToolsAgentHost* agent_host,
@ -113,8 +106,9 @@ DevToolsManagerDelegate::CreateNewTarget(const GURL& url) {
}
std::string DevToolsManagerDelegate::GetDiscoveryPageHTML() {
return ResourceBundle::GetSharedInstance().GetRawDataResource(
IDR_CONTENT_SHELL_DEVTOOLS_DISCOVERY_PAGE).as_string();
return ResourceBundle::GetSharedInstance()
.GetRawDataResource(IDR_CONTENT_SHELL_DEVTOOLS_DISCOVERY_PAGE)
.as_string();
}
std::string DevToolsManagerDelegate::GetFrontendResource(

7
brightray/browser/devtools_manager_delegate.h
View file

@ -22,10 +22,9 @@ class DevToolsManagerDelegate : public content::DevToolsManagerDelegate {
// DevToolsManagerDelegate implementation.
void Inspect(content::DevToolsAgentHost* agent_host) override;
bool HandleCommand(
content::DevToolsAgentHost* agent_host,
int session_id,
base::DictionaryValue* command) override;
bool HandleCommand(content::DevToolsAgentHost* agent_host,
int session_id,
base::DictionaryValue* command) override;
scoped_refptr<content::DevToolsAgentHost> CreateNewTarget(
const GURL& url) override;
std::string GetDiscoveryPageHTML() override;

19
brightray/browser/devtools_ui.cc
View file

@ -23,7 +23,8 @@ const char kChromeUIDevToolsBundledPath[] = "bundled";
std::string PathWithoutParams(const std::string& path) {
return GURL(std::string("chrome-devtools://devtools/") + path)
.path().substr(1);
.path()
.substr(1);
}
std::string GetMimeTypeForPath(const std::string& path) {
@ -57,9 +58,7 @@ class BundledDataSource : public content::URLDataSource {
BundledDataSource() {}
// content::URLDataSource implementation.
std::string GetSource() const override {
return kChromeUIDevToolsHost;
}
std::string GetSource() const override { return kChromeUIDevToolsHost; }
void StartDataRequest(
const std::string& path,
@ -83,17 +82,11 @@ class BundledDataSource : public content::URLDataSource {
return GetMimeTypeForPath(path);
}
bool ShouldAddContentSecurityPolicy() const override {
return false;
}
bool ShouldAddContentSecurityPolicy() const override { return false; }
bool ShouldDenyXFrameOptions() const override {
return false;
}
bool ShouldDenyXFrameOptions() const override { return false; }
bool ShouldServeMimeTypeAsContentTypeHeader() const override {
return true;
}
bool ShouldServeMimeTypeAsContentTypeHeader() const override { return true; }
void StartBundledDataRequest(const std::string& path,
const GotDataCallback& callback) {

23
brightray/browser/inspectable_web_contents_delegate.h
View file

@ -11,22 +11,21 @@ class InspectableWebContentsDelegate {
// Requested by WebContents of devtools.
virtual void DevToolsReloadPage() {}
virtual void DevToolsSaveToFile(
const std::string& url, const std::string& content, bool save_as) {}
virtual void DevToolsAppendToFile(
const std::string& url, const std::string& content) {}
virtual void DevToolsSaveToFile(const std::string& url,
const std::string& content,
bool save_as) {}
virtual void DevToolsAppendToFile(const std::string& url,
const std::string& content) {}
virtual void DevToolsRequestFileSystems() {}
virtual void DevToolsAddFileSystem(
const base::FilePath& file_system_path) {}
virtual void DevToolsAddFileSystem(const base::FilePath& file_system_path) {}
virtual void DevToolsRemoveFileSystem(
const base::FilePath& file_system_path) {}
virtual void DevToolsIndexPath(
int request_id, const std::string& file_system_path) {}
virtual void DevToolsIndexPath(int request_id,
const std::string& file_system_path) {}
virtual void DevToolsStopIndexing(int request_id) {}
virtual void DevToolsSearchInPath(
int request_id,
const std::string& file_system_path,
const std::string& query) {}
virtual void DevToolsSearchInPath(int request_id,
const std::string& file_system_path,
const std::string& query) {}
};
} // namespace brightray

137
brightray/browser/inspectable_web_contents_impl.cc
View file

@ -42,9 +42,9 @@ namespace brightray {
namespace {
const double kPresetZoomFactors[] = { 0.25, 0.333, 0.5, 0.666, 0.75, 0.9, 1.0,
1.1, 1.25, 1.5, 1.75, 2.0, 2.5, 3.0, 4.0,
5.0 };
const double kPresetZoomFactors[] = {0.25, 0.333, 0.5, 0.666, 0.75, 0.9,
1.0, 1.1, 1.25, 1.5, 1.75, 2.0,
2.5, 3.0, 4.0, 5.0};
const char kChromeUIDevToolsURL[] =
"chrome-devtools://devtools/bundled/inspector.html?"
@ -117,18 +117,16 @@ double GetNextZoomLevel(double level, bool out) {
}
GURL GetRemoteBaseURL() {
return GURL(base::StringPrintf(
"%s%s/%s/",
kChromeUIDevToolsRemoteFrontendBase,
kChromeUIDevToolsRemoteFrontendPath,
content::GetWebKitRevision().c_str()));
return GURL(base::StringPrintf("%s%s/%s/",
kChromeUIDevToolsRemoteFrontendBase,
kChromeUIDevToolsRemoteFrontendPath,
content::GetWebKitRevision().c_str()));
}
GURL GetDevToolsURL(bool can_dock) {
auto url_string =
base::StringPrintf(kChromeUIDevToolsURL,
GetRemoteBaseURL().spec().c_str(),
can_dock ? "true" : "");
auto url_string = base::StringPrintf(kChromeUIDevToolsURL,
GetRemoteBaseURL().spec().c_str(),
can_dock ? "true" : "");
return GURL(url_string);
}
@ -157,12 +155,9 @@ class ResponseWriter : public net::URLFetcherResponseWriter {
ResponseWriter::ResponseWriter(
base::WeakPtr<InspectableWebContentsImpl> bindings,
int stream_id)
: bindings_(bindings),
stream_id_(stream_id) {
}
: bindings_(bindings), stream_id_(stream_id) {}
ResponseWriter::~ResponseWriter() {
}
ResponseWriter::~ResponseWriter() {}
int ResponseWriter::Initialize(const net::CompletionCallback& callback) {
return net::OK;
@ -172,14 +167,13 @@ int ResponseWriter::Write(net::IOBuffer* buffer,
int num_bytes,
const net::CompletionCallback& callback) {
auto* id = new base::Value(stream_id_);
base::Value* chunk =
new base::Value(std::string(buffer->data(), num_bytes));
base::Value* chunk = new base::Value(std::string(buffer->data(), num_bytes));
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&InspectableWebContentsImpl::CallClientFunction,
bindings_, "DevToolsAPI.streamWrite",
base::Owned(id), base::Owned(chunk), nullptr));
base::Bind(&InspectableWebContentsImpl::CallClientFunction, bindings_,
"DevToolsAPI.streamWrite", base::Owned(id), base::Owned(chunk),
nullptr));
return num_bytes;
}
@ -223,8 +217,9 @@ InspectableWebContentsImpl::InspectableWebContentsImpl(
if (!IsPointInScreen(devtools_bounds_.origin())) {
gfx::Rect display;
if (web_contents->GetNativeView()) {
display = display::Screen::GetScreen()->
GetDisplayNearestView(web_contents->GetNativeView()).bounds();
display = display::Screen::GetScreen()
->GetDisplayNearestView(web_contents->GetNativeView())
.bounds();
} else {
display = display::Screen::GetScreen()->GetPrimaryDisplay().bounds();
}
@ -311,9 +306,8 @@ void InspectableWebContentsImpl::ShowDevTools() {
if (!external_devtools_web_contents_) { // no external devtools
managed_devtools_web_contents_.reset(
content::WebContents::Create(
content::WebContents::CreateParams(
web_contents_->GetBrowserContext())));
content::WebContents::Create(content::WebContents::CreateParams(
web_contents_->GetBrowserContext())));
managed_devtools_web_contents_->SetDelegate(this);
}
@ -321,10 +315,8 @@ void InspectableWebContentsImpl::ShowDevTools() {
AttachTo(content::DevToolsAgentHost::GetOrCreateFor(web_contents_.get()));
GetDevToolsWebContents()->GetController().LoadURL(
GetDevToolsURL(can_dock_),
content::Referrer(),
ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
std::string());
GetDevToolsURL(can_dock_), content::Referrer(),
ui::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string());
}
void InspectableWebContentsImpl::CloseDevTools() {
@ -406,8 +398,7 @@ void InspectableWebContentsImpl::UpdateDevToolsZoomLevel(double level) {
void InspectableWebContentsImpl::ActivateWindow() {
// Set the zoom level.
SetZoomLevelForWebContents(GetDevToolsWebContents(),
GetDevToolsZoomLevel());
SetZoomLevelForWebContents(GetDevToolsWebContents(), GetDevToolsZoomLevel());
}
void InspectableWebContentsImpl::CloseWindow() {
@ -424,8 +415,8 @@ void InspectableWebContentsImpl::LoadCompleted() {
SetIsDocked(DispatchCallback(), false);
} else {
if (dock_state_.empty()) {
const base::DictionaryValue* prefs = pref_service_->GetDictionary(
kDevToolsPreferences);
const base::DictionaryValue* prefs =
pref_service_->GetDictionary(kDevToolsPreferences);
std::string current_dock_state;
prefs->GetString("currentDockState", &current_dock_state);
base::RemoveChars(current_dock_state, "\"", &dock_state_);
@ -449,13 +440,12 @@ void InspectableWebContentsImpl::SetInspectedPageBounds(const gfx::Rect& rect) {
view_->SetContentsResizingStrategy(contents_resizing_strategy_);
}
void InspectableWebContentsImpl::InspectElementCompleted() {
}
void InspectableWebContentsImpl::InspectElementCompleted() {}
void InspectableWebContentsImpl::InspectedURLChanged(const std::string& url) {
if (managed_devtools_web_contents_)
view_->SetTitle(base::UTF8ToUTF16(base::StringPrintf(kTitleFormat,
url.c_str())));
view_->SetTitle(
base::UTF8ToUTF16(base::StringPrintf(kTitleFormat, url.c_str())));
}
void InspectableWebContentsImpl::LoadNetworkResource(
@ -493,17 +483,17 @@ void InspectableWebContentsImpl::SetIsDocked(const DispatchCallback& callback,
callback.Run(nullptr);
}
void InspectableWebContentsImpl::OpenInNewTab(const std::string& url) {
}
void InspectableWebContentsImpl::OpenInNewTab(const std::string& url) {}
void InspectableWebContentsImpl::SaveToFile(
const std::string& url, const std::string& content, bool save_as) {
void InspectableWebContentsImpl::SaveToFile(const std::string& url,
const std::string& content,
bool save_as) {
if (delegate_)
delegate_->DevToolsSaveToFile(url, content, save_as);
}
void InspectableWebContentsImpl::AppendToFile(
const std::string& url, const std::string& content) {
void InspectableWebContentsImpl::AppendToFile(const std::string& url,
const std::string& content) {
if (delegate_)
delegate_->DevToolsAppendToFile(url, content);
}
@ -528,11 +518,11 @@ void InspectableWebContentsImpl::RemoveFileSystem(
}
void InspectableWebContentsImpl::UpgradeDraggedFileSystemPermissions(
const std::string& file_system_url) {
}
const std::string& file_system_url) {}
void InspectableWebContentsImpl::IndexPath(
int request_id, const std::string& file_system_path) {
int request_id,
const std::string& file_system_path) {
if (delegate_)
delegate_->DevToolsIndexPath(request_id, file_system_path);
}
@ -551,8 +541,7 @@ void InspectableWebContentsImpl::SearchInPath(
}
void InspectableWebContentsImpl::SetWhitelistedShortcuts(
const std::string& message) {
}
const std::string& message) {}
void InspectableWebContentsImpl::ZoomIn() {
double new_level = GetNextZoomLevel(GetDevToolsZoomLevel(), false);
@ -571,16 +560,16 @@ void InspectableWebContentsImpl::ResetZoom() {
UpdateDevToolsZoomLevel(0.);
}
void InspectableWebContentsImpl::SetDevicesUpdatesEnabled(bool enabled) {
}
void InspectableWebContentsImpl::SetDevicesUpdatesEnabled(bool enabled) {}
void InspectableWebContentsImpl::DispatchProtocolMessageFromDevToolsFrontend(
const std::string& message) {
// If the devtools wants to reload the page, hijack the message and handle it
// to the delegate.
if (base::MatchPattern(message, "{\"id\":*,"
"\"method\":\"Page.reload\","
"\"params\":*}")) {
if (base::MatchPattern(message,
"{\"id\":*,"
"\"method\":\"Page.reload\","
"\"params\":*}")) {
if (delegate_)
delegate_->DevToolsReloadPage();
return;
@ -599,8 +588,8 @@ void InspectableWebContentsImpl::SendJsonRequest(
void InspectableWebContentsImpl::GetPreferences(
const DispatchCallback& callback) {
const base::DictionaryValue* prefs = pref_service_->GetDictionary(
kDevToolsPreferences);
const base::DictionaryValue* prefs =
pref_service_->GetDictionary(kDevToolsPreferences);
callback.Run(prefs);
}
@ -634,11 +623,10 @@ void InspectableWebContentsImpl::HandleMessageFromDevToolsFrontend(
base::DictionaryValue* dict = nullptr;
std::unique_ptr<base::Value> parsed_message(base::JSONReader::Read(message));
if (!parsed_message ||
!parsed_message->GetAsDictionary(&dict) ||
if (!parsed_message || !parsed_message->GetAsDictionary(&dict) ||
!dict->GetString(kFrontendHostMethod, &method) ||
(dict->HasKey(kFrontendHostParams) &&
!dict->GetList(kFrontendHostParams, &params))) {
!dict->GetList(kFrontendHostParams, &params))) {
LOG(ERROR) << "Invalid message was sent to embedder: " << message;
return;
}
@ -646,20 +634,19 @@ void InspectableWebContentsImpl::HandleMessageFromDevToolsFrontend(
dict->GetInteger(kFrontendHostId, &id);
embedder_message_dispatcher_->Dispatch(
base::Bind(&InspectableWebContentsImpl::SendMessageAck,
weak_factory_.GetWeakPtr(),
id),
method,
params);
weak_factory_.GetWeakPtr(), id),
method, params);
}
void InspectableWebContentsImpl::DispatchProtocolMessage(
content::DevToolsAgentHost* agent_host, const std::string& message) {
content::DevToolsAgentHost* agent_host,
const std::string& message) {
if (!frontend_loaded_)
return;
if (message.length() < kMaxMessageChunkSize) {
base::string16 javascript = base::UTF8ToUTF16(
"DevToolsAPI.dispatchMessage(" + message + ");");
base::string16 javascript =
base::UTF8ToUTF16("DevToolsAPI.dispatchMessage(" + message + ");");
GetDevToolsWebContents()->GetMainFrame()->ExecuteJavaScript(javascript);
return;
}
@ -667,14 +654,14 @@ void InspectableWebContentsImpl::DispatchProtocolMessage(
base::Value total_size(static_cast<int>(message.length()));
for (size_t pos = 0; pos < message.length(); pos += kMaxMessageChunkSize) {
base::Value message_value(message.substr(pos, kMaxMessageChunkSize));
CallClientFunction("DevToolsAPI.dispatchMessageChunk",
&message_value, pos ? nullptr : &total_size, nullptr);
CallClientFunction("DevToolsAPI.dispatchMessageChunk", &message_value,
pos ? nullptr : &total_size, nullptr);
}
}
void InspectableWebContentsImpl::AgentHostClosed(
content::DevToolsAgentHost* agent_host, bool replaced) {
}
content::DevToolsAgentHost* agent_host,
bool replaced) {}
void InspectableWebContentsImpl::RenderFrameHostChanged(
content::RenderFrameHost* old_host,
@ -707,8 +694,9 @@ bool InspectableWebContentsImpl::DidAddMessageToConsole(
const base::string16& message,
int32_t line_no,
const base::string16& source_id) {
logging::LogMessage("CONSOLE", line_no, level).stream() << "\"" <<
message << "\", source: " << source_id << " (" << line_no << ")";
logging::LogMessage("CONSOLE", line_no, level).stream()
<< "\"" << message << "\", source: " << source_id << " (" << line_no
<< ")";
return true;
}
@ -846,8 +834,7 @@ void InspectableWebContentsImpl::OnURLFetchComplete(
void InspectableWebContentsImpl::SendMessageAck(int request_id,
const base::Value* arg) {
base::Value id_value(request_id);
CallClientFunction("DevToolsAPI.embedderMessageAck",
&id_value, arg, nullptr);
CallClientFunction("DevToolsAPI.embedderMessageAck", &id_value, arg, nullptr);
}
} // namespace brightray

21
brightray/browser/inspectable_web_contents_impl.h
View file

@ -29,13 +29,13 @@ namespace brightray {
class InspectableWebContentsDelegate;
class InspectableWebContentsView;
class InspectableWebContentsImpl :
public InspectableWebContents,
public content::DevToolsAgentHostClient,
public content::WebContentsObserver,
public content::WebContentsDelegate,
public DevToolsEmbedderMessageDispatcher::Delegate,
public net::URLFetcherDelegate {
class InspectableWebContentsImpl
: public InspectableWebContents,
public content::DevToolsAgentHostClient,
public content::WebContentsObserver,
public content::WebContentsDelegate,
public DevToolsEmbedderMessageDispatcher::Delegate,
public net::URLFetcherDelegate {
public:
static void RegisterPrefs(PrefRegistrySimple* pref_registry);
@ -156,8 +156,8 @@ class InspectableWebContentsImpl :
const GURL& target_url,
const std::string& partition_id,
content::SessionStorageNamespace* session_storage_namespace) override;
void HandleKeyboardEvent(
content::WebContents*, const content::NativeWebKeyboardEvent&) override;
void HandleKeyboardEvent(content::WebContents*,
const content::NativeWebKeyboardEvent&) override;
void CloseContents(content::WebContents* source) override;
content::ColorChooser* OpenColorChooser(
content::WebContents* source,
@ -172,8 +172,7 @@ class InspectableWebContentsImpl :
// net::URLFetcherDelegate:
void OnURLFetchComplete(const net::URLFetcher* source) override;
void SendMessageAck(int request_id,
const base::Value* arg1);
void SendMessageAck(int request_id, const base::Value* arg1);
bool frontend_loaded_;
scoped_refptr<content::DevToolsAgentHost> agent_host_;

4
brightray/browser/inspectable_web_contents_view.h
View file

@ -25,9 +25,7 @@ class InspectableWebContentsView {
void SetDelegate(InspectableWebContentsViewDelegate* delegate) {
delegate_ = delegate;
}
InspectableWebContentsViewDelegate* GetDelegate() const {
return delegate_;
}
InspectableWebContentsViewDelegate* GetDelegate() const { return delegate_; }
#if defined(TOOLKIT_VIEWS)
// Returns the container control, which has devtools view attached.

1
brightray/browser/inspectable_web_contents_view_delegate.cc
View file

@ -7,4 +7,3 @@ gfx::ImageSkia InspectableWebContentsViewDelegate::GetDevToolsWindowIcon() {
}
} // namespace brightray

4
brightray/browser/inspectable_web_contents_view_delegate.h
View file

@ -20,8 +20,8 @@ class InspectableWebContentsViewDelegate {
#if defined(USE_X11)
// Called when creating devtools window.
virtual void GetDevToolsWindowWMClass(
std::string* name, std::string* class_name) {}
virtual void GetDevToolsWindowWMClass(std::string* name,
std::string* class_name) {}
#endif
};

2
brightray/browser/io_thread.h
View file

@ -13,7 +13,7 @@
namespace net {
class URLRequestContext;
class URLRequestContextGetter;
}
} // namespace net
namespace brightray {

13
brightray/browser/linux/libnotify_loader.cc
View file

@ -6,8 +6,7 @@
#include <dlfcn.h>
LibNotifyLoader::LibNotifyLoader() : loaded_(false) {
}
LibNotifyLoader::LibNotifyLoader() : loaded_(false) {}
LibNotifyLoader::~LibNotifyLoader() {
CleanUp(loaded_);
@ -21,17 +20,15 @@ bool LibNotifyLoader::Load(const std::string& library_name) {
if (!library_)
return false;
notify_is_initted =
reinterpret_cast<decltype(this->notify_is_initted)>(
dlsym(library_, "notify_is_initted"));
notify_is_initted = reinterpret_cast<decltype(this->notify_is_initted)>(
dlsym(library_, "notify_is_initted"));
if (!notify_is_initted) {
CleanUp(true);
return false;
}
notify_init =
reinterpret_cast<decltype(this->notify_init)>(
dlsym(library_, "notify_init"));
notify_init = reinterpret_cast<decltype(this->notify_init)>(
dlsym(library_, "notify_init"));
if (!notify_init) {
CleanUp(true);
return false;

36
brightray/browser/linux/libnotify_notification.cc
View file

@ -29,7 +29,7 @@ const std::set<std::string>& GetServerCapabilities() {
static std::set<std::string> caps;
if (caps.empty()) {
auto capabilities = libnotify_loader_.notify_get_server_caps();
for (auto l=capabilities; l != nullptr; l=l->next)
for (auto l = capabilities; l != nullptr; l = l->next)
caps.insert(static_cast<const char*>(l->data));
g_list_free_full(capabilities, g_free);
}
@ -48,10 +48,9 @@ bool NotifierSupportsActions() {
}
void log_and_clear_error(GError* error, const char* context) {
LOG(ERROR) << context
<< ": domain=" << error->domain
<< " code=" << error->code
<< " message=\"" << error->message << '"';
LOG(ERROR) << context << ": domain=" << error->domain
<< " code=" << error->code << " message=\"" << error->message
<< '"';
g_error_free(error);
}
@ -76,9 +75,7 @@ bool LibnotifyNotification::Initialize() {
LibnotifyNotification::LibnotifyNotification(NotificationDelegate* delegate,
NotificationPresenter* presenter)
: Notification(delegate, presenter),
notification_(nullptr) {
}
: Notification(delegate, presenter), notification_(nullptr) {}
LibnotifyNotification::~LibnotifyNotification() {
if (notification_) {
@ -90,11 +87,10 @@ LibnotifyNotification::~LibnotifyNotification() {
void LibnotifyNotification::Show(const NotificationOptions& options) {
notification_ = libnotify_loader_.notify_notification_new(
base::UTF16ToUTF8(options.title).c_str(),
base::UTF16ToUTF8(options.msg).c_str(),
nullptr);
base::UTF16ToUTF8(options.msg).c_str(), nullptr);
g_signal_connect(
notification_, "closed", G_CALLBACK(OnNotificationClosedThunk), this);
g_signal_connect(notification_, "closed",
G_CALLBACK(OnNotificationClosedThunk), this);
// NB: On Unity and on any other DE using Notify-OSD, adding a notification
// action will cause the notification to display as a modal dialog box.
@ -106,10 +102,10 @@ void LibnotifyNotification::Show(const NotificationOptions& options) {
if (!options.icon.drawsNothing()) {
GdkPixbuf* pixbuf = libgtkui::GdkPixbufFromSkBitmap(options.icon);
libnotify_loader_.notify_notification_set_image_from_pixbuf(
notification_, pixbuf);
libnotify_loader_.notify_notification_set_timeout(
notification_, NOTIFY_EXPIRES_DEFAULT);
libnotify_loader_.notify_notification_set_image_from_pixbuf(notification_,
pixbuf);
libnotify_loader_.notify_notification_set_timeout(notification_,
NOTIFY_EXPIRES_DEFAULT);
g_object_unref(pixbuf);
}
@ -121,8 +117,8 @@ void LibnotifyNotification::Show(const NotificationOptions& options) {
// Always try to append notifications.
// Unique tags can be used to prevent this.
if (HasCapability("append")) {
libnotify_loader_.notify_notification_set_hint_string(
notification_, "append", "true");
libnotify_loader_.notify_notification_set_hint_string(notification_,
"append", "true");
} else if (HasCapability("x-canonical-append")) {
libnotify_loader_.notify_notification_set_hint_string(
notification_, "x-canonical-append", "true");
@ -172,8 +168,8 @@ void LibnotifyNotification::OnNotificationClosed(
NotificationDismissed();
}
void LibnotifyNotification::OnNotificationView(
NotifyNotification* notification, char* action) {
void LibnotifyNotification::OnNotificationView(NotifyNotification* notification,
char* action) {
NotificationClicked();
}

11
brightray/browser/linux/libnotify_notification.h
View file

@ -27,10 +27,15 @@ class LibnotifyNotification : public Notification {
void Dismiss() override;
private:
CHROMEG_CALLBACK_0(LibnotifyNotification, void, OnNotificationClosed,
CHROMEG_CALLBACK_0(LibnotifyNotification,
void,
OnNotificationClosed,
NotifyNotification*);
CHROMEG_CALLBACK_1(LibnotifyNotification, void, OnNotificationView,
NotifyNotification*, char*);
CHROMEG_CALLBACK_1(LibnotifyNotification,
void,
OnNotificationView,
NotifyNotification*,
char*);
NotifyNotification* notification_;

6
brightray/browser/linux/notification_presenter_linux.cc
View file

@ -16,11 +16,9 @@ NotificationPresenter* NotificationPresenter::Create() {
return new NotificationPresenterLinux;
}
NotificationPresenterLinux::NotificationPresenterLinux() {
}
NotificationPresenterLinux::NotificationPresenterLinux() {}
NotificationPresenterLinux::~NotificationPresenterLinux() {
}
NotificationPresenterLinux::~NotificationPresenterLinux() {}
Notification* NotificationPresenterLinux::CreateNotificationObject(
NotificationDelegate* delegate) {

10
brightray/browser/mac/bry_inspectable_web_contents_view.h
View file

@ -10,8 +10,8 @@ class InspectableWebContentsViewMac;
using brightray::InspectableWebContentsViewMac;
@interface BRYInspectableWebContentsView : BaseView<NSWindowDelegate> {
@private
@interface BRYInspectableWebContentsView : BaseView <NSWindowDelegate> {
@private
brightray::InspectableWebContentsViewMac* inspectableWebContentsView_;
base::scoped_nsobject<NSWindow> devtools_window_;
@ -22,14 +22,16 @@ using brightray::InspectableWebContentsViewMac;
DevToolsContentsResizingStrategy strategy_;
}
- (instancetype)initWithInspectableWebContentsViewMac:(InspectableWebContentsViewMac*)view;
- (instancetype)initWithInspectableWebContentsViewMac:
(InspectableWebContentsViewMac*)view;
- (void)removeObservers;
- (void)notifyDevToolsFocused;
- (void)setDevToolsVisible:(BOOL)visible;
- (BOOL)isDevToolsVisible;
- (BOOL)isDevToolsFocused;
- (void)setIsDocked:(BOOL)docked;
- (void)setContentsResizingStrategy:(const DevToolsContentsResizingStrategy&)strategy;
- (void)setContentsResizingStrategy:
(const DevToolsContentsResizingStrategy&)strategy;
- (void)setTitle:(NSString*)title;
@end

7
brightray/browser/mac/notification_center_delegate.h
View file

@ -11,12 +11,13 @@ namespace brightray {
class NotificationPresenterMac;
}
@interface NotificationCenterDelegate :
NSObject<NSUserNotificationCenterDelegate> {
@interface NotificationCenterDelegate
: NSObject <NSUserNotificationCenterDelegate> {
@private
brightray::NotificationPresenterMac* presenter_;
}
- (instancetype)initWithPresenter:(brightray::NotificationPresenterMac*)presenter;
- (instancetype)initWithPresenter:
(brightray::NotificationPresenterMac*)presenter;
@end
#endif // BROWSER_MAC_NOTIFICATION_DELEGATE_H_

18
brightray/browser/media/media_capture_devices_dispatcher.cc
View file

@ -127,11 +127,9 @@ void MediaCaptureDevicesDispatcher::DisableDeviceEnumerationForTesting() {
is_device_enumeration_disabled_ = true;
}
void MediaCaptureDevicesDispatcher::OnAudioCaptureDevicesChanged() {
}
void MediaCaptureDevicesDispatcher::OnAudioCaptureDevicesChanged() {}
void MediaCaptureDevicesDispatcher::OnVideoCaptureDevicesChanged() {
}
void MediaCaptureDevicesDispatcher::OnVideoCaptureDevicesChanged() {}
void MediaCaptureDevicesDispatcher::OnMediaRequestStateChanged(
int render_process_id,
@ -139,20 +137,16 @@ void MediaCaptureDevicesDispatcher::OnMediaRequestStateChanged(
int page_request_id,
const GURL& security_origin,
content::MediaStreamType stream_type,
content::MediaRequestState state) {
}
content::MediaRequestState state) {}
void MediaCaptureDevicesDispatcher::OnCreatingAudioStream(
int render_process_id,
int render_view_id) {
}
void MediaCaptureDevicesDispatcher::OnCreatingAudioStream(int render_process_id,
int render_view_id) {}
void MediaCaptureDevicesDispatcher::OnSetCapturingLinkSecured(
int render_process_id,
int render_frame_id,
int page_request_id,
content::MediaStreamType stream_type,
bool is_secure) {
}
bool is_secure) {}
} // namespace brightray

21
brightray/browser/media/media_capture_devices_dispatcher.h
View file

@ -34,10 +34,10 @@ class MediaCaptureDevicesDispatcher : public content::MediaObserver {
// Helpers for picking particular requested devices, identified by raw id.
// If the device requested is not available it will return NULL.
const content::MediaStreamDevice*
GetRequestedAudioDevice(const std::string& requested_audio_device_id);
const content::MediaStreamDevice*
GetRequestedVideoDevice(const std::string& requested_video_device_id);
const content::MediaStreamDevice* GetRequestedAudioDevice(
const std::string& requested_audio_device_id);
const content::MediaStreamDevice* GetRequestedVideoDevice(
const std::string& requested_video_device_id);
// Returns the first available audio or video device, or NULL if no devices
// are available.
@ -52,13 +52,12 @@ class MediaCaptureDevicesDispatcher : public content::MediaObserver {
// Overridden from content::MediaObserver:
void OnAudioCaptureDevicesChanged() override;
void OnVideoCaptureDevicesChanged() override;
void OnMediaRequestStateChanged(
int render_process_id,
int render_view_id,
int page_request_id,
const GURL& security_origin,
content::MediaStreamType stream_type,
content::MediaRequestState state) override;
void OnMediaRequestStateChanged(int render_process_id,
int render_view_id,
int page_request_id,
const GURL& security_origin,
content::MediaStreamType stream_type,
content::MediaRequestState state) override;
void OnCreatingAudioStream(int render_process_id,
int render_view_id) override;
void OnSetCapturingLinkSecured(int render_process_id,

69
brightray/browser/media/media_stream_devices_controller.cc
View file

@ -35,8 +35,7 @@ MediaStreamDevicesController::MediaStreamDevicesController(
request.request_type == content::MEDIA_OPEN_DEVICE_PEPPER_ONLY),
webcam_requested_(
request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE ||
request.request_type == content::MEDIA_OPEN_DEVICE_PEPPER_ONLY) {
}
request.request_type == content::MEDIA_OPEN_DEVICE_PEPPER_ONLY) {}
MediaStreamDevicesController::~MediaStreamDevicesController() {
if (!callback_.is_null()) {
@ -76,35 +75,38 @@ void MediaStreamDevicesController::Accept() {
// For open device request pick the desired device or fall back to the
// first available of the given type.
if (request_.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE) {
device = MediaCaptureDevicesDispatcher::GetInstance()->
GetRequestedAudioDevice(request_.requested_audio_device_id);
device =
MediaCaptureDevicesDispatcher::GetInstance()
->GetRequestedAudioDevice(request_.requested_audio_device_id);
// TODO(wjia): Confirm this is the intended behavior.
if (!device) {
device = MediaCaptureDevicesDispatcher::GetInstance()->
GetFirstAvailableAudioDevice();
device = MediaCaptureDevicesDispatcher::GetInstance()
->GetFirstAvailableAudioDevice();
}
} else if (request_.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE) {
// Pepper API opens only one device at a time.
device = MediaCaptureDevicesDispatcher::GetInstance()->
GetRequestedVideoDevice(request_.requested_video_device_id);
device =
MediaCaptureDevicesDispatcher::GetInstance()
->GetRequestedVideoDevice(request_.requested_video_device_id);
// TODO(wjia): Confirm this is the intended behavior.
if (!device) {
device = MediaCaptureDevicesDispatcher::GetInstance()->
GetFirstAvailableVideoDevice();
device = MediaCaptureDevicesDispatcher::GetInstance()
->GetFirstAvailableVideoDevice();
}
}
if (device)
devices.push_back(*device);
break;
} case content::MEDIA_GENERATE_STREAM: {
}
case content::MEDIA_GENERATE_STREAM: {
bool needs_audio_device = microphone_requested_;
bool needs_video_device = webcam_requested_;
// Get the exact audio or video device if an id is specified.
if (!request_.requested_audio_device_id.empty()) {
const content::MediaStreamDevice* audio_device =
MediaCaptureDevicesDispatcher::GetInstance()->
GetRequestedAudioDevice(request_.requested_audio_device_id);
MediaCaptureDevicesDispatcher::GetInstance()
->GetRequestedAudioDevice(request_.requested_audio_device_id);
if (audio_device) {
devices.push_back(*audio_device);
needs_audio_device = false;
@ -112,8 +114,8 @@ void MediaStreamDevicesController::Accept() {
}
if (!request_.requested_video_device_id.empty()) {
const content::MediaStreamDevice* video_device =
MediaCaptureDevicesDispatcher::GetInstance()->
GetRequestedVideoDevice(request_.requested_video_device_id);
MediaCaptureDevicesDispatcher::GetInstance()
->GetRequestedVideoDevice(request_.requested_video_device_id);
if (video_device) {
devices.push_back(*video_device);
needs_video_device = false;
@ -123,18 +125,15 @@ void MediaStreamDevicesController::Accept() {
// If either or both audio and video devices were requested but not
// specified by id, get the default devices.
if (needs_audio_device || needs_video_device) {
MediaCaptureDevicesDispatcher::GetInstance()->
GetDefaultDevices(needs_audio_device,
needs_video_device,
&devices);
MediaCaptureDevicesDispatcher::GetInstance()->GetDefaultDevices(
needs_audio_device, needs_video_device, &devices);
}
break;
} case content::MEDIA_DEVICE_ACCESS:
}
case content::MEDIA_DEVICE_ACCESS:
// Get the default devices for the request.
MediaCaptureDevicesDispatcher::GetInstance()->
GetDefaultDevices(microphone_requested_,
webcam_requested_,
&devices);
MediaCaptureDevicesDispatcher::GetInstance()->GetDefaultDevices(
microphone_requested_, webcam_requested_, &devices);
break;
}
}
@ -149,8 +148,7 @@ void MediaStreamDevicesController::Deny(
content::MediaStreamRequestResult result) {
content::MediaResponseCallback cb = callback_;
callback_.Reset();
cb.Run(content::MediaStreamDevices(),
result,
cb.Run(content::MediaStreamDevices(), result,
std::unique_ptr<content::MediaStreamUI>());
}
@ -158,12 +156,12 @@ void MediaStreamDevicesController::HandleUserMediaRequest() {
content::MediaStreamDevices devices;
if (request_.audio_type == content::MEDIA_TAB_AUDIO_CAPTURE) {
devices.push_back(content::MediaStreamDevice(
content::MEDIA_TAB_AUDIO_CAPTURE, "", ""));
devices.push_back(
content::MediaStreamDevice(content::MEDIA_TAB_AUDIO_CAPTURE, "", ""));
}
if (request_.video_type == content::MEDIA_TAB_VIDEO_CAPTURE) {
devices.push_back(content::MediaStreamDevice(
content::MEDIA_TAB_VIDEO_CAPTURE, "", ""));
devices.push_back(
content::MediaStreamDevice(content::MEDIA_TAB_VIDEO_CAPTURE, "", ""));
}
if (request_.audio_type == content::MEDIA_DESKTOP_AUDIO_CAPTURE) {
devices.push_back(content::MediaStreamDevice(
@ -175,22 +173,21 @@ void MediaStreamDevicesController::HandleUserMediaRequest() {
// (i.e. chooseDesktopMedia() API wasn't used to generate device id).
if (request_.requested_video_device_id.empty()) {
screen_id = content::DesktopMediaID(content::DesktopMediaID::TYPE_SCREEN,
-1 /* kFullDesktopScreenId */);
-1 /* kFullDesktopScreenId */);
} else {
screen_id =
content::DesktopMediaID::Parse(request_.requested_video_device_id);
}
devices.push_back(
content::MediaStreamDevice(content::MEDIA_DESKTOP_VIDEO_CAPTURE,
screen_id.ToString(), "Screen"));
devices.push_back(content::MediaStreamDevice(
content::MEDIA_DESKTOP_VIDEO_CAPTURE, screen_id.ToString(), "Screen"));
}
content::MediaResponseCallback cb = callback_;
callback_.Reset();
cb.Run(devices,
devices.empty() ? content::MEDIA_DEVICE_INVALID_STATE :
content::MEDIA_DEVICE_OK,
devices.empty() ? content::MEDIA_DEVICE_INVALID_STATE
: content::MEDIA_DEVICE_OK,
std::unique_ptr<content::MediaStreamUI>());
}

3
brightray/browser/net_log.cc
View file

@ -33,8 +33,7 @@ std::unique_ptr<base::DictionaryValue> GetConstants() {
} // namespace
NetLog::NetLog() {
}
NetLog::NetLog() {}
NetLog::~NetLog() {
if (file_net_log_observer_) {

53
brightray/browser/network_delegate.cc
View file

@ -32,13 +32,11 @@ NetworkDelegate::NetworkDelegate() {
}
}
NetworkDelegate::~NetworkDelegate() {
}
NetworkDelegate::~NetworkDelegate() {}
int NetworkDelegate::OnBeforeURLRequest(
net::URLRequest* request,
const net::CompletionCallback& callback,
GURL* new_url) {
int NetworkDelegate::OnBeforeURLRequest(net::URLRequest* request,
const net::CompletionCallback& callback,
GURL* new_url) {
for (const auto& domain : ignore_connections_limit_domains_) {
if (request->url().DomainIs(domain)) {
// Allow unlimited concurrent connections.
@ -60,15 +58,13 @@ int NetworkDelegate::OnBeforeStartTransaction(
void NetworkDelegate::OnStartTransaction(
net::URLRequest* request,
const net::HttpRequestHeaders& headers) {
}
const net::HttpRequestHeaders& headers) {}
void NetworkDelegate::OnBeforeSendHeaders(
net::URLRequest* request,
const net::ProxyInfo& proxy_info,
const net::ProxyRetryInfoMap& proxy_retry_info,
net::HttpRequestHeaders* headers) {
}
net::HttpRequestHeaders* headers) {}
int NetworkDelegate::OnHeadersReceived(
net::URLRequest* request,
@ -80,29 +76,22 @@ int NetworkDelegate::OnHeadersReceived(
}
void NetworkDelegate::OnBeforeRedirect(net::URLRequest* request,
const GURL& new_location) {
}
const GURL& new_location) {}
void NetworkDelegate::OnResponseStarted(net::URLRequest* request) {
}
void NetworkDelegate::OnResponseStarted(net::URLRequest* request) {}
void NetworkDelegate::OnNetworkBytesReceived(net::URLRequest* request,
int64_t bytes_read) {
}
int64_t bytes_read) {}
void NetworkDelegate::OnNetworkBytesSent(net::URLRequest* request,
int64_t bytes_sent) {
}
int64_t bytes_sent) {}
void NetworkDelegate::OnCompleted(net::URLRequest* request, bool started) {
}
void NetworkDelegate::OnCompleted(net::URLRequest* request, bool started) {}
void NetworkDelegate::OnURLRequestDestroyed(net::URLRequest* request) {
}
void NetworkDelegate::OnURLRequestDestroyed(net::URLRequest* request) {}
void NetworkDelegate::OnPACScriptError(int line_number,
const base::string16& error) {
}
const base::string16& error) {}
NetworkDelegate::AuthRequiredResponse NetworkDelegate::OnAuthRequired(
net::URLRequest* request,
@ -113,13 +102,13 @@ NetworkDelegate::AuthRequiredResponse NetworkDelegate::OnAuthRequired(
}
bool NetworkDelegate::OnCanGetCookies(const net::URLRequest& request,
const net::CookieList& cookie_list) {
const net::CookieList& cookie_list) {
return true;
}
bool NetworkDelegate::OnCanSetCookie(const net::URLRequest& request,
const std::string& cookie_line,
net::CookieOptions* options) {
const std::string& cookie_line,
net::CookieOptions* options) {
return true;
}
@ -159,15 +148,13 @@ bool NetworkDelegate::OnCanSendReportingReport(
return false;
}
bool NetworkDelegate::OnCanSetReportingClient(
const url::Origin& origin,
const GURL& endpoint) const {
bool NetworkDelegate::OnCanSetReportingClient(const url::Origin& origin,
const GURL& endpoint) const {
return false;
}
bool NetworkDelegate::OnCanUseReportingClient(
const url::Origin& origin,
const GURL& endpoint) const {
bool NetworkDelegate::OnCanUseReportingClient(const url::Origin& origin,
const GURL& endpoint) const {
return false;
}

3
brightray/browser/network_delegate.h
View file

@ -45,8 +45,7 @@ class NetworkDelegate : public net::NetworkDelegate {
int64_t bytes_sent) override;
void OnCompleted(net::URLRequest* request, bool started) override;
void OnURLRequestDestroyed(net::URLRequest* request) override;
void OnPACScriptError(int line_number,
const base::string16& error) override;
void OnPACScriptError(int line_number, const base::string16& error) override;
AuthRequiredResponse OnAuthRequired(
net::URLRequest* request,
const net::AuthChallengeInfo& auth_info,

5
brightray/browser/notification.cc
View file

@ -11,10 +11,7 @@ namespace brightray {
Notification::Notification(NotificationDelegate* delegate,
NotificationPresenter* presenter)
: delegate_(delegate),
presenter_(presenter),
weak_factory_(this) {
}
: delegate_(delegate), presenter_(presenter), weak_factory_(this) {}
Notification::~Notification() {
if (delegate())

3
brightray/browser/notification_presenter.cc
View file

@ -8,8 +8,7 @@
namespace brightray {
NotificationPresenter::NotificationPresenter() {
}
NotificationPresenter::NotificationPresenter() {}
NotificationPresenter::~NotificationPresenter() {
for (Notification* notification : notifications_)

29
brightray/browser/permission_manager.cc
View file

@ -12,11 +12,9 @@
namespace brightray {
PermissionManager::PermissionManager() {
}
PermissionManager::PermissionManager() {}
PermissionManager::~PermissionManager() {
}
PermissionManager::~PermissionManager() {}
int PermissionManager::RequestPermission(
content::PermissionType permission,
@ -25,8 +23,8 @@ int PermissionManager::RequestPermission(
bool user_gesture,
const base::Callback<void(blink::mojom::PermissionStatus)>& callback) {
if (permission == content::PermissionType::MIDI_SYSEX) {
content::ChildProcessSecurityPolicy::GetInstance()->
GrantSendMidiSysExMessage(render_frame_host->GetProcess()->GetID());
content::ChildProcessSecurityPolicy::GetInstance()
->GrantSendMidiSysExMessage(render_frame_host->GetProcess()->GetID());
}
callback.Run(blink::mojom::PermissionStatus::GRANTED);
return kNoPendingOperation;
@ -37,14 +35,14 @@ int PermissionManager::RequestPermissions(
content::RenderFrameHost* render_frame_host,
const GURL& requesting_origin,
bool user_gesture,
const base::Callback<void(
const std::vector<blink::mojom::PermissionStatus>&)>& callback) {
const base::Callback<
void(const std::vector<blink::mojom::PermissionStatus>&)>& callback) {
std::vector<blink::mojom::PermissionStatus> permissionStatuses;
for (auto permission : permissions) {
if (permission == content::PermissionType::MIDI_SYSEX) {
content::ChildProcessSecurityPolicy::GetInstance()->
GrantSendMidiSysExMessage(render_frame_host->GetProcess()->GetID());
content::ChildProcessSecurityPolicy::GetInstance()
->GrantSendMidiSysExMessage(render_frame_host->GetProcess()->GetID());
}
permissionStatuses.push_back(blink::mojom::PermissionStatus::GRANTED);
@ -54,14 +52,11 @@ int PermissionManager::RequestPermissions(
return kNoPendingOperation;
}
void PermissionManager::CancelPermissionRequest(int request_id) {
}
void PermissionManager::CancelPermissionRequest(int request_id) {}
void PermissionManager::ResetPermission(
content::PermissionType permission,
const GURL& requesting_origin,
const GURL& embedding_origin) {
}
void PermissionManager::ResetPermission(content::PermissionType permission,
const GURL& requesting_origin,
const GURL& embedding_origin) {}
blink::mojom::PermissionStatus PermissionManager::GetPermissionStatus(
content::PermissionType permission,

13
brightray/browser/platform_notification_service.cc
View file

@ -77,9 +77,7 @@ class NotificationDelegateImpl final : public brightray::NotificationDelegate {
PlatformNotificationService::PlatformNotificationService(
BrowserClient* browser_client)
: browser_client_(browser_client),
render_process_id_(-1) {
}
: browser_client_(browser_client), render_process_id_(-1) {}
PlatformNotificationService::~PlatformNotificationService() {}
@ -128,17 +126,14 @@ void PlatformNotificationService::DisplayPersistentNotification(
const GURL& service_worker_scope,
const GURL& origin,
const content::PlatformNotificationData& notification_data,
const content::NotificationResources& notification_resources) {
}
const content::NotificationResources& notification_resources) {}
void PlatformNotificationService::ClosePersistentNotification(
content::BrowserContext* browser_context,
const std::string& notification_id) {
}
const std::string& notification_id) {}
void PlatformNotificationService::GetDisplayedNotifications(
content::BrowserContext* browser_context,
const DisplayedNotificationsCallback& callback) {
}
const DisplayedNotificationsCallback& callback) {}
} // namespace brightray

6
brightray/browser/special_storage_policy.cc
View file

@ -6,11 +6,9 @@
namespace brightray {
SpecialStoragePolicy::SpecialStoragePolicy() {
}
SpecialStoragePolicy::SpecialStoragePolicy() {}
SpecialStoragePolicy::~SpecialStoragePolicy() {
}
SpecialStoragePolicy::~SpecialStoragePolicy() {}
bool SpecialStoragePolicy::IsStorageProtected(const GURL& origin) {
return true;

41
brightray/browser/url_request_context_getter.cc
View file

@ -67,8 +67,8 @@ URLRequestContextGetter::Delegate::CreateURLRequestJobFactory(
new net::URLRequestJobFactoryImpl);
for (auto& it : *protocol_handlers) {
job_factory->SetProtocolHandler(
it.first, base::WrapUnique(it.second.release()));
job_factory->SetProtocolHandler(it.first,
base::WrapUnique(it.second.release()));
}
protocol_handlers->clear();
@ -94,10 +94,7 @@ URLRequestContextGetter::Delegate::CreateHttpCacheBackendFactory(
base::FilePath cache_path = base_path.Append(FILE_PATH_LITERAL("Cache"));
return new net::HttpCache::DefaultBackend(
net::DISK_CACHE,
net::CACHE_BACKEND_DEFAULT,
cache_path,
max_size);
net::DISK_CACHE, net::CACHE_BACKEND_DEFAULT, cache_path, max_size);
}
std::unique_ptr<net::CertVerifier>
@ -113,7 +110,7 @@ URLRequestContextGetter::Delegate::CreateSSLConfigService() {
std::vector<std::string>
URLRequestContextGetter::Delegate::GetCookieableSchemes() {
return { "http", "https", "ws", "wss" };
return {"http", "https", "ws", "wss"};
}
URLRequestContextGetter::URLRequestContextGetter(
@ -144,12 +141,11 @@ URLRequestContextGetter::URLRequestContextGetter(
// We must create the proxy config service on the UI loop on Linux because it
// must synchronously run on the glib message loop. This will be passed to
// the URLRequestContextStorage on the IO thread in GetURLRequestContext().
proxy_config_service_ = net::ProxyService::CreateSystemProxyConfigService(
io_task_runner_);
proxy_config_service_ =
net::ProxyService::CreateSystemProxyConfigService(io_task_runner_);
}
URLRequestContextGetter::~URLRequestContextGetter() {
}
URLRequestContextGetter::~URLRequestContextGetter() {}
void URLRequestContextGetter::NotifyContextShutdownOnIO() {
context_shutting_down_ = true;
@ -204,11 +200,11 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
storage_->set_network_delegate(delegate_->CreateNetworkDelegate());
auto cookie_path = in_memory_ ?
base::FilePath() : base_path_.Append(FILE_PATH_LITERAL("Cookies"));
auto cookie_path = in_memory_
? base::FilePath()
: base_path_.Append(FILE_PATH_LITERAL("Cookies"));
auto cookie_config = content::CookieStoreConfig(
cookie_path,
content::CookieStoreConfig::EPHEMERAL_SESSION_COOKIES,
cookie_path, content::CookieStoreConfig::EPHEMERAL_SESSION_COOKIES,
nullptr);
cookie_config.cookieable_schemes = delegate_->GetCookieableSchemes();
std::unique_ptr<net::CookieStore> cookie_store =
@ -255,13 +251,11 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
auto proxy_config = net::ProxyConfig::CreateFromCustomPacURL(
GURL(command_line.GetSwitchValueASCII(switches::kProxyPacUrl)));
proxy_config.set_pac_mandatory(true);
storage_->set_proxy_service(net::ProxyService::CreateFixed(
proxy_config));
storage_->set_proxy_service(net::ProxyService::CreateFixed(proxy_config));
} else {
storage_->set_proxy_service(
net::ProxyService::CreateUsingSystemProxyResolver(
std::move(proxy_config_service_),
net_log_));
std::move(proxy_config_service_), net_log_));
}
std::vector<std::string> schemes;
@ -270,8 +264,8 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
schemes.push_back(std::string("ntlm"));
schemes.push_back(std::string("negotiate"));
#if defined(OS_POSIX)
http_auth_preferences_.reset(new net::HttpAuthPreferences(schemes,
std::string()));
http_auth_preferences_.reset(
new net::HttpAuthPreferences(schemes, std::string()));
#else
http_auth_preferences_.reset(new net::HttpAuthPreferences(schemes));
#endif
@ -289,9 +283,8 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
switches::kAuthNegotiateDelegateWhitelist));
}
auto auth_handler_factory =
net::HttpAuthHandlerRegistryFactory::Create(
http_auth_preferences_.get(), host_resolver.get());
auto auth_handler_factory = net::HttpAuthHandlerRegistryFactory::Create(
http_auth_preferences_.get(), host_resolver.get());
std::unique_ptr<net::TransportSecurityState> transport_security_state =
base::WrapUnique(new net::TransportSecurityState);

2
brightray/browser/url_request_context_getter.h
View file

@ -34,7 +34,7 @@ class NetworkDelegate;
class ProxyConfigService;
class URLRequestContextStorage;
class URLRequestJobFactory;
}
} // namespace net
namespace brightray {

12
brightray/browser/views/inspectable_web_contents_view_views.cc
View file

@ -87,8 +87,8 @@ InspectableWebContentsViewViews::InspectableWebContentsViewViews(
inspectable_web_contents_->GetWebContents());
contents_web_view_ = contents_web_view;
} else {
contents_web_view_ = new views::Label(
base::ASCIIToUTF16("No content under offscreen mode"));
contents_web_view_ =
new views::Label(base::ASCIIToUTF16("No content under offscreen mode"));
}
devtools_web_view_->SetVisible(false);
@ -168,9 +168,7 @@ void InspectableWebContentsViewViews::SetIsDocked(bool docked) {
devtools_window_.reset(new views::Widget);
devtools_window_web_view_ = new views::WebView(NULL);
devtools_window_delegate_ = new DevToolsWindowDelegate(
this,
devtools_window_web_view_,
devtools_window_.get());
this, devtools_window_web_view_, devtools_window_.get());
views::Widget::InitParams params;
params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
@ -213,8 +211,8 @@ void InspectableWebContentsViewViews::Layout() {
gfx::Size container_size(width(), height());
gfx::Rect new_devtools_bounds;
gfx::Rect new_contents_bounds;
ApplyDevToolsContentsResizingStrategy(strategy_, container_size,
&new_devtools_bounds, &new_contents_bounds);
ApplyDevToolsContentsResizingStrategy(
strategy_, container_size, &new_devtools_bounds, &new_contents_bounds);
// DevTools cares about the specific position, so we have to compensate RTL
// layout here.

2
brightray/browser/views/inspectable_web_contents_view_views.h
View file

@ -10,7 +10,7 @@ namespace views {
class WebView;
class Widget;
class WidgetDelegate;
}
} // namespace views
namespace brightray {

37
brightray/browser/views/views_delegate.cc
View file

@ -30,17 +30,14 @@ bool IsDesktopEnvironmentUnity() {
namespace brightray {
ViewsDelegate::ViewsDelegate() {
}
ViewsDelegate::ViewsDelegate() {}
ViewsDelegate::~ViewsDelegate() {
}
ViewsDelegate::~ViewsDelegate() {}
void ViewsDelegate::SaveWindowPlacement(const views::Widget* window,
const std::string& window_name,
const gfx::Rect& bounds,
ui::WindowShowState show_state) {
}
ui::WindowShowState show_state) {}
bool ViewsDelegate::GetSavedWindowPlacement(
const views::Widget* widget,
@ -50,23 +47,20 @@ bool ViewsDelegate::GetSavedWindowPlacement(
return false;
}
void ViewsDelegate::NotifyAccessibilityEvent(
views::View* view, ui::AXEvent event_type) {
}
void ViewsDelegate::NotifyAccessibilityEvent(views::View* view,
ui::AXEvent event_type) {}
void ViewsDelegate::NotifyMenuItemFocused(
const base::string16& menu_name,
const base::string16& menu_item_name,
int item_index,
int item_count,
bool has_submenu) {
}
void ViewsDelegate::NotifyMenuItemFocused(const base::string16& menu_name,
const base::string16& menu_item_name,
int item_index,
int item_count,
bool has_submenu) {}
#if defined(OS_WIN)
HICON ViewsDelegate::GetDefaultWindowIcon() const {
// Use current exe's icon as default window icon.
return LoadIcon(GetModuleHandle(NULL),
MAKEINTRESOURCE(1 /* IDR_MAINFRAME */));
MAKEINTRESOURCE(1 /* IDR_MAINFRAME */));
}
HICON ViewsDelegate::GetSmallWindowIcon() const {
@ -88,11 +82,9 @@ views::NonClientFrameView* ViewsDelegate::CreateDefaultNonClientFrameView(
return NULL;
}
void ViewsDelegate::AddRef() {
}
void ViewsDelegate::AddRef() {}
void ViewsDelegate::ReleaseRef() {
}
void ViewsDelegate::ReleaseRef() {}
content::WebContents* ViewsDelegate::CreateWebContents(
content::BrowserContext* browser_context,
@ -108,8 +100,7 @@ void ViewsDelegate::OnBeforeWidgetInit(
if (params->native_widget)
return;
if (params->parent &&
params->type != views::Widget::InitParams::TYPE_MENU &&
if (params->parent && params->type != views::Widget::InitParams::TYPE_MENU &&
params->type != views::Widget::InitParams::TYPE_TOOLTIP) {
params->native_widget = new views::NativeWidgetAura(delegate);
} else {

13
brightray/browser/views/views_delegate.h
View file

@ -23,13 +23,12 @@ class ViewsDelegate : public views::ViewsDelegate {
const std::string& window_name,
const gfx::Rect& bounds,
ui::WindowShowState show_state) override;
bool GetSavedWindowPlacement(
const views::Widget* widget,
const std::string& window_name,
gfx::Rect* bounds,
ui::WindowShowState* show_state) const override;
void NotifyAccessibilityEvent(
views::View* view, ui::AXEvent event_type) override;
bool GetSavedWindowPlacement(const views::Widget* widget,
const std::string& window_name,
gfx::Rect* bounds,
ui::WindowShowState* show_state) const override;
void NotifyAccessibilityEvent(views::View* view,
ui::AXEvent event_type) override;
void NotifyMenuItemFocused(const base::string16& menu_name,
const base::string16& menu_item_name,
int item_index,

18
brightray/browser/web_ui_controller_factory.cc
View file

@ -23,14 +23,13 @@ WebUIControllerFactory* WebUIControllerFactory::GetInstance() {
return base::Singleton<WebUIControllerFactory>::get();
}
WebUIControllerFactory::WebUIControllerFactory() {
}
WebUIControllerFactory::WebUIControllerFactory() {}
WebUIControllerFactory::~WebUIControllerFactory() {
}
WebUIControllerFactory::~WebUIControllerFactory() {}
content::WebUI::TypeID WebUIControllerFactory::GetWebUIType(
content::BrowserContext* browser_context, const GURL& url) const {
content::BrowserContext* browser_context,
const GURL& url) const {
if (url.host() == kChromeUIDevToolsBundledHost) {
return const_cast<WebUIControllerFactory*>(this);
}
@ -39,17 +38,20 @@ content::WebUI::TypeID WebUIControllerFactory::GetWebUIType(
}
bool WebUIControllerFactory::UseWebUIForURL(
content::BrowserContext* browser_context, const GURL& url) const {
content::BrowserContext* browser_context,
const GURL& url) const {
return GetWebUIType(browser_context, url) != content::WebUI::kNoWebUI;
}
bool WebUIControllerFactory::UseWebUIBindingsForURL(
content::BrowserContext* browser_context, const GURL& url) const {
content::BrowserContext* browser_context,
const GURL& url) const {
return UseWebUIForURL(browser_context, url);
}
content::WebUIController* WebUIControllerFactory::CreateWebUIControllerForURL(
content::WebUI* web_ui, const GURL& url) const {
content::WebUI* web_ui,
const GURL& url) const {
if (url.host() == kChromeUIDevToolsBundledHost) {
auto browser_context = web_ui->GetWebContents()->GetBrowserContext();
return new DevToolsUI(browser_context, web_ui);

7
brightray/browser/web_ui_controller_factory.h
View file

@ -10,7 +10,8 @@
#include "content/public/browser/web_ui_controller_factory.h"
namespace base {
template <typename T> struct DefaultSingletonTraits;
template <typename T>
struct DefaultSingletonTraits;
}
namespace brightray {
@ -24,8 +25,8 @@ class WebUIControllerFactory : public content::WebUIControllerFactory {
WebUIControllerFactory();
virtual ~WebUIControllerFactory();
content::WebUI::TypeID GetWebUIType(
content::BrowserContext* browser_context, const GURL& url) const override;
content::WebUI::TypeID GetWebUIType(content::BrowserContext* browser_context,
const GURL& url) const override;
bool UseWebUIForURL(content::BrowserContext* browser_context,
const GURL& url) const override;
bool UseWebUIBindingsForURL(content::BrowserContext* browser_context,

9
brightray/browser/win/notification_presenter_win.cc
View file

@ -62,11 +62,9 @@ NotificationPresenter* NotificationPresenter::Create() {
return presenter.release();
}
NotificationPresenterWin::NotificationPresenterWin() {
}
NotificationPresenterWin::NotificationPresenterWin() {}
NotificationPresenterWin::~NotificationPresenterWin() {
}
NotificationPresenterWin::~NotificationPresenterWin() {}
bool NotificationPresenterWin::Init() {
base::ThreadRestrictions::ScopedAllowIO allow_io;
@ -74,7 +72,8 @@ bool NotificationPresenterWin::Init() {
}
base::string16 NotificationPresenterWin::SaveIconToFilesystem(
const SkBitmap& icon, const GURL& origin) {
const SkBitmap& icon,
const GURL& origin) {
std::string filename;
if (origin.is_valid()) {

38
brightray/browser/win/notification_presenter_win7.cc
View file

@ -8,41 +8,43 @@ namespace brightray {
brightray::Notification* NotificationPresenterWin7::CreateNotificationObject(
NotificationDelegate* delegate) {
return new Win32Notification(delegate, this);
return new Win32Notification(delegate, this);
}
Win32Notification* NotificationPresenterWin7::GetNotificationObjectByRef(
const DesktopNotificationController::Notification& ref) {
for (auto n : this->notifications()) {
auto w32n = static_cast<Win32Notification*>(n);
if (w32n->GetRef() == ref)
return w32n;
}
for (auto n : this->notifications()) {
auto w32n = static_cast<Win32Notification*>(n);
if (w32n->GetRef() == ref)
return w32n;
}
return nullptr;
return nullptr;
}
Win32Notification* NotificationPresenterWin7::GetNotificationObjectByTag(
const std::string& tag) {
for (auto n : this->notifications()) {
auto w32n = static_cast<Win32Notification*>(n);
if (w32n->GetTag() == tag)
return w32n;
}
for (auto n : this->notifications()) {
auto w32n = static_cast<Win32Notification*>(n);
if (w32n->GetTag() == tag)
return w32n;
}
return nullptr;
return nullptr;
}
void NotificationPresenterWin7::OnNotificationClicked(
Notification& notification) {
auto n = GetNotificationObjectByRef(notification);
if (n) n->NotificationClicked();
auto n = GetNotificationObjectByRef(notification);
if (n)
n->NotificationClicked();
}
void NotificationPresenterWin7::OnNotificationDismissed(
Notification& notification) {
auto n = GetNotificationObjectByRef(notification);
if (n) n->NotificationDismissed();
auto n = GetNotificationObjectByRef(notification);
if (n)
n->NotificationDismissed();
}
} // namespace brightray
} // namespace brightray

25
brightray/browser/win/notification_presenter_win7.h
View file

@ -6,25 +6,24 @@ namespace brightray {
class Win32Notification;
class NotificationPresenterWin7 :
public NotificationPresenter,
public DesktopNotificationController {
class NotificationPresenterWin7 : public NotificationPresenter,
public DesktopNotificationController {
public:
NotificationPresenterWin7() = default;
NotificationPresenterWin7() = default;
Win32Notification* GetNotificationObjectByRef(
const DesktopNotificationController::Notification& ref);
Win32Notification* GetNotificationObjectByRef(
const DesktopNotificationController::Notification& ref);
Win32Notification* GetNotificationObjectByTag(const std::string& tag);
Win32Notification* GetNotificationObjectByTag(const std::string& tag);
private:
brightray::Notification* CreateNotificationObject(
NotificationDelegate* delegate) override;
brightray::Notification* CreateNotificationObject(
NotificationDelegate* delegate) override;
void OnNotificationClicked(Notification& notification) override;
void OnNotificationDismissed(Notification& notification) override;
void OnNotificationClicked(Notification& notification) override;
void OnNotificationDismissed(Notification& notification) override;
DISALLOW_COPY_AND_ASSIGN(NotificationPresenterWin7);
DISALLOW_COPY_AND_ASSIGN(NotificationPresenterWin7);
};
} // namespace brightray
} // namespace brightray

9
brightray/browser/win/scoped_hstring.cc
View file

@ -6,18 +6,15 @@
#include <winstring.h>
ScopedHString::ScopedHString(const wchar_t* source)
: str_(nullptr) {
ScopedHString::ScopedHString(const wchar_t* source) : str_(nullptr) {
Reset(source);
}
ScopedHString::ScopedHString(const std::wstring& source)
: str_(nullptr) {
ScopedHString::ScopedHString(const std::wstring& source) : str_(nullptr) {
Reset(source);
}
ScopedHString::ScopedHString() : str_(nullptr) {
}
ScopedHString::ScopedHString() : str_(nullptr) {}
ScopedHString::~ScopedHString() {
Reset();

68
brightray/browser/win/win32_desktop_notifications/common.h
View file

@ -4,51 +4,57 @@
namespace brightray {
struct NotificationData {
DesktopNotificationController* controller = nullptr;
DesktopNotificationController* controller = nullptr;
std::wstring caption;
std::wstring body_text;
HBITMAP image = NULL;
std::wstring caption;
std::wstring body_text;
HBITMAP image = NULL;
NotificationData() = default;
NotificationData() = default;
~NotificationData() {
if (image) DeleteObject(image);
}
~NotificationData() {
if (image)
DeleteObject(image);
}
NotificationData(const NotificationData& other) = delete;
NotificationData& operator=(const NotificationData& other) = delete;
NotificationData(const NotificationData& other) = delete;
NotificationData& operator=(const NotificationData& other) = delete;
};
template<typename T>
template <typename T>
constexpr T ScaleForDpi(T value, unsigned dpi, unsigned source_dpi = 96) {
return value * dpi / source_dpi;
return value * dpi / source_dpi;
}
struct ScreenMetrics {
UINT dpi_x, dpi_y;
UINT dpi_x, dpi_y;
ScreenMetrics() {
typedef HRESULT WINAPI GetDpiForMonitor_t(HMONITOR, int, UINT*, UINT*);
ScreenMetrics() {
typedef HRESULT WINAPI GetDpiForMonitor_t(HMONITOR, int, UINT*, UINT*);
auto GetDpiForMonitor = reinterpret_cast<GetDpiForMonitor_t*>(
GetProcAddress(GetModuleHandle(TEXT("shcore")),
"GetDpiForMonitor"));
auto GetDpiForMonitor = reinterpret_cast<GetDpiForMonitor_t*>(
GetProcAddress(GetModuleHandle(TEXT("shcore")), "GetDpiForMonitor"));
if (GetDpiForMonitor) {
auto monitor = MonitorFromPoint({}, MONITOR_DEFAULTTOPRIMARY);
if (GetDpiForMonitor(monitor, 0, &dpi_x, &dpi_y) == S_OK)
return;
}
HDC hdc = GetDC(NULL);
dpi_x = GetDeviceCaps(hdc, LOGPIXELSX);
dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
ReleaseDC(NULL, hdc);
if (GetDpiForMonitor) {
auto monitor = MonitorFromPoint({}, MONITOR_DEFAULTTOPRIMARY);
if (GetDpiForMonitor(monitor, 0, &dpi_x, &dpi_y) == S_OK)
return;
}
template<class T> T X(T value) const { return ScaleForDpi(value, dpi_x); }
template<class T> T Y(T value) const { return ScaleForDpi(value, dpi_y); }
HDC hdc = GetDC(NULL);
dpi_x = GetDeviceCaps(hdc, LOGPIXELSX);
dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
ReleaseDC(NULL, hdc);
}
template <class T>
T X(T value) const {
return ScaleForDpi(value, dpi_x);
}
template <class T>
T Y(T value) const {
return ScaleForDpi(value, dpi_y);
}
};
} // namespace brightray
} // namespace brightray

550
brightray/browser/win/win32_desktop_notifications/desktop_notification_controller.cc
View file

@ -13,393 +13,405 @@ using std::shared_ptr;
namespace brightray {
HBITMAP CopyBitmap(HBITMAP bitmap) {
HBITMAP ret = NULL;
HBITMAP ret = NULL;
BITMAP bm;
if (bitmap && GetObject(bitmap, sizeof(bm), &bm)) {
HDC hdc_screen = GetDC(NULL);
ret = CreateCompatibleBitmap(hdc_screen, bm.bmWidth, bm.bmHeight);
ReleaseDC(NULL, hdc_screen);
BITMAP bm;
if (bitmap && GetObject(bitmap, sizeof(bm), &bm)) {
HDC hdc_screen = GetDC(NULL);
ret = CreateCompatibleBitmap(hdc_screen, bm.bmWidth, bm.bmHeight);
ReleaseDC(NULL, hdc_screen);
if (ret) {
HDC hdc_src = CreateCompatibleDC(NULL);
HDC hdc_dst = CreateCompatibleDC(NULL);
SelectBitmap(hdc_src, bitmap);
SelectBitmap(hdc_dst, ret);
BitBlt(hdc_dst, 0, 0, bm.bmWidth, bm.bmHeight,
hdc_src, 0, 0, SRCCOPY);
DeleteDC(hdc_dst);
DeleteDC(hdc_src);
}
if (ret) {
HDC hdc_src = CreateCompatibleDC(NULL);
HDC hdc_dst = CreateCompatibleDC(NULL);
SelectBitmap(hdc_src, bitmap);
SelectBitmap(hdc_dst, ret);
BitBlt(hdc_dst, 0, 0, bm.bmWidth, bm.bmHeight, hdc_src, 0, 0, SRCCOPY);
DeleteDC(hdc_dst);
DeleteDC(hdc_src);
}
}
return ret;
return ret;
}
HINSTANCE DesktopNotificationController::RegisterWndClasses() {
// We keep a static `module` variable which serves a dual purpose:
// 1. Stores the HINSTANCE where the window classes are registered,
// which can be passed to `CreateWindow`
// 2. Indicates whether we already attempted the registration so that
// we don't do it twice (we don't retry even if registration fails,
// as there is no point).
static HMODULE module = NULL;
// We keep a static `module` variable which serves a dual purpose:
// 1. Stores the HINSTANCE where the window classes are registered,
// which can be passed to `CreateWindow`
// 2. Indicates whether we already attempted the registration so that
// we don't do it twice (we don't retry even if registration fails,
// as there is no point).
static HMODULE module = NULL;
if (!module) {
if (GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
reinterpret_cast<LPCWSTR>(&RegisterWndClasses),
&module)) {
Toast::Register(module);
if (!module) {
if (GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
reinterpret_cast<LPCWSTR>(&RegisterWndClasses),
&module)) {
Toast::Register(module);
WNDCLASSEX wc = { sizeof(wc) };
wc.lpfnWndProc = &WndProc;
wc.lpszClassName = class_name_;
wc.cbWndExtra = sizeof(DesktopNotificationController*);
wc.hInstance = module;
WNDCLASSEX wc = {sizeof(wc)};
wc.lpfnWndProc = &WndProc;
wc.lpszClassName = class_name_;
wc.cbWndExtra = sizeof(DesktopNotificationController*);
wc.hInstance = module;
RegisterClassEx(&wc);
}
RegisterClassEx(&wc);
}
}
return module;
return module;
}
DesktopNotificationController::DesktopNotificationController(
unsigned maximum_toasts) {
instances_.reserve(maximum_toasts);
instances_.reserve(maximum_toasts);
}
DesktopNotificationController::~DesktopNotificationController() {
for (auto&& inst : instances_) DestroyToast(inst);
if (hwnd_controller_) DestroyWindow(hwnd_controller_);
ClearAssets();
for (auto&& inst : instances_)
DestroyToast(inst);
if (hwnd_controller_)
DestroyWindow(hwnd_controller_);
ClearAssets();
}
LRESULT CALLBACK DesktopNotificationController::WndProc(
HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
switch (message) {
case WM_CREATE:
{
auto& cs = reinterpret_cast<const CREATESTRUCT*&>(lparam);
SetWindowLongPtr(hwnd, 0, (LONG_PTR)cs->lpCreateParams);
}
break;
LRESULT CALLBACK DesktopNotificationController::WndProc(HWND hwnd,
UINT message,
WPARAM wparam,
LPARAM lparam) {
switch (message) {
case WM_CREATE: {
auto& cs = reinterpret_cast<const CREATESTRUCT*&>(lparam);
SetWindowLongPtr(hwnd, 0, (LONG_PTR)cs->lpCreateParams);
} break;
case WM_TIMER:
if (wparam == TimerID_Animate) {
Get(hwnd)->AnimateAll();
}
return 0;
if (wparam == TimerID_Animate) {
Get(hwnd)->AnimateAll();
}
return 0;
case WM_DISPLAYCHANGE:
{
auto inst = Get(hwnd);
inst->ClearAssets();
inst->AnimateAll();
}
break;
case WM_DISPLAYCHANGE: {
auto inst = Get(hwnd);
inst->ClearAssets();
inst->AnimateAll();
} break;
case WM_SETTINGCHANGE:
if (wparam == SPI_SETWORKAREA) {
Get(hwnd)->AnimateAll();
}
break;
}
if (wparam == SPI_SETWORKAREA) {
Get(hwnd)->AnimateAll();
}
break;
}
return DefWindowProc(hwnd, message, wparam, lparam);
return DefWindowProc(hwnd, message, wparam, lparam);
}
void DesktopNotificationController::StartAnimation() {
_ASSERT(hwnd_controller_);
_ASSERT(hwnd_controller_);
if (!is_animating_ && hwnd_controller_) {
// NOTE: 15ms is shorter than what we'd need for 60 fps, but since
// the timer is not accurate we must request a higher frame rate
// to get at least 60
if (!is_animating_ && hwnd_controller_) {
// NOTE: 15ms is shorter than what we'd need for 60 fps, but since
// the timer is not accurate we must request a higher frame rate
// to get at least 60
SetTimer(hwnd_controller_, TimerID_Animate, 15, nullptr);
is_animating_ = true;
}
SetTimer(hwnd_controller_, TimerID_Animate, 15, nullptr);
is_animating_ = true;
}
}
HFONT DesktopNotificationController::GetCaptionFont() {
InitializeFonts();
return caption_font_;
InitializeFonts();
return caption_font_;
}
HFONT DesktopNotificationController::GetBodyFont() {
InitializeFonts();
return body_font_;
InitializeFonts();
return body_font_;
}
void DesktopNotificationController::InitializeFonts() {
if (!body_font_) {
NONCLIENTMETRICS metrics = { sizeof(metrics) };
if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &metrics, 0)) {
auto base_height = metrics.lfMessageFont.lfHeight;
if (!body_font_) {
NONCLIENTMETRICS metrics = {sizeof(metrics)};
if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &metrics, 0)) {
auto base_height = metrics.lfMessageFont.lfHeight;
HDC hdc = GetDC(NULL);
auto base_dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
ReleaseDC(NULL, hdc);
HDC hdc = GetDC(NULL);
auto base_dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
ReleaseDC(NULL, hdc);
ScreenMetrics scr;
ScreenMetrics scr;
metrics.lfMessageFont.lfHeight =
(LONG)ScaleForDpi(base_height * 1.1f, scr.dpi_y, base_dpi_y);
body_font_ = CreateFontIndirect(&metrics.lfMessageFont);
metrics.lfMessageFont.lfHeight =
(LONG)ScaleForDpi(base_height * 1.1f, scr.dpi_y, base_dpi_y);
body_font_ = CreateFontIndirect(&metrics.lfMessageFont);
if (caption_font_) DeleteFont(caption_font_);
metrics.lfMessageFont.lfHeight =
(LONG)ScaleForDpi(base_height * 1.4f, scr.dpi_y, base_dpi_y);
caption_font_ = CreateFontIndirect(&metrics.lfMessageFont);
}
if (caption_font_)
DeleteFont(caption_font_);
metrics.lfMessageFont.lfHeight =
(LONG)ScaleForDpi(base_height * 1.4f, scr.dpi_y, base_dpi_y);
caption_font_ = CreateFontIndirect(&metrics.lfMessageFont);
}
}
}
void DesktopNotificationController::ClearAssets() {
if (caption_font_) { DeleteFont(caption_font_); caption_font_ = NULL; }
if (body_font_) { DeleteFont(body_font_); body_font_ = NULL; }
if (caption_font_) {
DeleteFont(caption_font_);
caption_font_ = NULL;
}
if (body_font_) {
DeleteFont(body_font_);
body_font_ = NULL;
}
}
void DesktopNotificationController::AnimateAll() {
// NOTE: This function refreshes position and size of all toasts according
// to all current conditions. Animation time is only one of the variables
// influencing them. Screen resolution is another.
// NOTE: This function refreshes position and size of all toasts according
// to all current conditions. Animation time is only one of the variables
// influencing them. Screen resolution is another.
bool keep_animating = false;
bool keep_animating = false;
if (!instances_.empty()) {
RECT work_area;
if (SystemParametersInfo(SPI_GETWORKAREA, 0, &work_area, 0)) {
ScreenMetrics metrics;
POINT origin = { work_area.right,
work_area.bottom - metrics.Y(toast_margin_) };
if (!instances_.empty()) {
RECT work_area;
if (SystemParametersInfo(SPI_GETWORKAREA, 0, &work_area, 0)) {
ScreenMetrics metrics;
POINT origin = {work_area.right,
work_area.bottom - metrics.Y(toast_margin_)};
auto hdwp =
BeginDeferWindowPos(static_cast<int>(instances_.size()));
auto hdwp = BeginDeferWindowPos(static_cast<int>(instances_.size()));
for (auto&& inst : instances_) {
if (!inst.hwnd) continue;
for (auto&& inst : instances_) {
if (!inst.hwnd)
continue;
auto notification = Toast::Get(inst.hwnd);
hdwp = notification->Animate(hdwp, origin);
if (!hdwp) break;
keep_animating |= notification->IsAnimationActive();
}
auto notification = Toast::Get(inst.hwnd);
hdwp = notification->Animate(hdwp, origin);
if (!hdwp)
break;
keep_animating |= notification->IsAnimationActive();
}
if (hdwp) EndDeferWindowPos(hdwp);
}
if (hdwp)
EndDeferWindowPos(hdwp);
}
}
if (!keep_animating) {
_ASSERT(hwnd_controller_);
if (hwnd_controller_) KillTimer(hwnd_controller_, TimerID_Animate);
is_animating_ = false;
if (!keep_animating) {
_ASSERT(hwnd_controller_);
if (hwnd_controller_)
KillTimer(hwnd_controller_, TimerID_Animate);
is_animating_ = false;
}
// Purge dismissed notifications and collapse the stack between
// items which are highlighted
if (!instances_.empty()) {
auto is_alive = [](ToastInstance& inst) {
return inst.hwnd && IsWindowVisible(inst.hwnd);
};
auto is_highlighted = [](ToastInstance& inst) {
return inst.hwnd && Toast::Get(inst.hwnd)->IsHighlighted();
};
for (auto it = instances_.begin();; ++it) {
// find next highlighted item
auto it2 = find_if(it, instances_.end(), is_highlighted);
// collapse the stack in front of the highlighted item
it = stable_partition(it, it2, is_alive);
// purge the dead items
for_each(it, it2, [this](auto&& inst) { DestroyToast(inst); });
if (it2 == instances_.end()) {
instances_.erase(it, it2);
break;
}
it = move(it2);
}
}
// Purge dismissed notifications and collapse the stack between
// items which are highlighted
if (!instances_.empty()) {
auto is_alive = [](ToastInstance& inst) {
return inst.hwnd && IsWindowVisible(inst.hwnd);
};
// Set new toast positions
if (!instances_.empty()) {
ScreenMetrics metrics;
auto margin = metrics.Y(toast_margin_);
auto is_highlighted = [](ToastInstance& inst) {
return inst.hwnd && Toast::Get(inst.hwnd)->IsHighlighted();
};
int target_pos = 0;
for (auto&& inst : instances_) {
if (inst.hwnd) {
auto toast = Toast::Get(inst.hwnd);
for (auto it = instances_.begin();; ++it) {
// find next highlighted item
auto it2 = find_if(it, instances_.end(), is_highlighted);
if (toast->IsHighlighted())
target_pos = toast->GetVerticalPosition();
else
toast->SetVerticalPosition(target_pos);
// collapse the stack in front of the highlighted item
it = stable_partition(it, it2, is_alive);
// purge the dead items
for_each(it, it2, [this](auto&& inst) { DestroyToast(inst); });
if (it2 == instances_.end()) {
instances_.erase(it, it2);
break;
}
it = move(it2);
}
target_pos += toast->GetHeight() + margin;
}
}
}
// Set new toast positions
if (!instances_.empty()) {
ScreenMetrics metrics;
auto margin = metrics.Y(toast_margin_);
int target_pos = 0;
for (auto&& inst : instances_) {
if (inst.hwnd) {
auto toast = Toast::Get(inst.hwnd);
if (toast->IsHighlighted())
target_pos = toast->GetVerticalPosition();
else
toast->SetVerticalPosition(target_pos);
target_pos += toast->GetHeight() + margin;
}
}
}
// Create new toasts from the queue
CheckQueue();
// Create new toasts from the queue
CheckQueue();
}
DesktopNotificationController::Notification
DesktopNotificationController::AddNotification(
std::wstring caption, std::wstring body_text, HBITMAP image) {
NotificationLink data(this);
DesktopNotificationController::AddNotification(std::wstring caption,
std::wstring body_text,
HBITMAP image) {
NotificationLink data(this);
data->caption = move(caption);
data->body_text = move(body_text);
data->image = CopyBitmap(image);
data->caption = move(caption);
data->body_text = move(body_text);
data->image = CopyBitmap(image);
// Enqueue new notification
Notification ret { *queue_.insert(queue_.end(), move(data)) };
CheckQueue();
return ret;
// Enqueue new notification
Notification ret{*queue_.insert(queue_.end(), move(data))};
CheckQueue();
return ret;
}
void DesktopNotificationController::CloseNotification(
Notification& notification) {
// Remove it from the queue
auto it = find(queue_.begin(), queue_.end(), notification.data_);
if (it != queue_.end()) {
queue_.erase(it);
this->OnNotificationClosed(notification);
return;
}
// Remove it from the queue
auto it = find(queue_.begin(), queue_.end(), notification.data_);
if (it != queue_.end()) {
queue_.erase(it);
this->OnNotificationClosed(notification);
return;
}
// Dismiss active toast
auto hwnd = GetToast(notification.data_.get());
if (hwnd) {
auto toast = Toast::Get(hwnd);
toast->Dismiss();
}
// Dismiss active toast
auto hwnd = GetToast(notification.data_.get());
if (hwnd) {
auto toast = Toast::Get(hwnd);
toast->Dismiss();
}
}
void DesktopNotificationController::CheckQueue() {
while (instances_.size() < instances_.capacity() && !queue_.empty()) {
CreateToast(move(queue_.front()));
queue_.pop_front();
}
while (instances_.size() < instances_.capacity() && !queue_.empty()) {
CreateToast(move(queue_.front()));
queue_.pop_front();
}
}
void DesktopNotificationController::CreateToast(NotificationLink&& data) {
auto hinstance = RegisterWndClasses();
auto hwnd = Toast::Create(hinstance, data);
if (hwnd) {
int toast_pos = 0;
if (!instances_.empty()) {
auto& item = instances_.back();
_ASSERT(item.hwnd);
auto hinstance = RegisterWndClasses();
auto hwnd = Toast::Create(hinstance, data);
if (hwnd) {
int toast_pos = 0;
if (!instances_.empty()) {
auto& item = instances_.back();
_ASSERT(item.hwnd);
ScreenMetrics scr;
auto toast = Toast::Get(item.hwnd);
toast_pos = toast->GetVerticalPosition() +
toast->GetHeight() +
scr.Y(toast_margin_);
}
instances_.push_back({ hwnd, move(data) });
if (!hwnd_controller_) {
// NOTE: We cannot use a message-only window because we need to
// receive system notifications
hwnd_controller_ = CreateWindow(class_name_, nullptr, 0,
0, 0, 0, 0,
NULL, NULL, hinstance, this);
}
auto toast = Toast::Get(hwnd);
toast->PopUp(toast_pos);
ScreenMetrics scr;
auto toast = Toast::Get(item.hwnd);
toast_pos = toast->GetVerticalPosition() + toast->GetHeight() +
scr.Y(toast_margin_);
}
instances_.push_back({hwnd, move(data)});
if (!hwnd_controller_) {
// NOTE: We cannot use a message-only window because we need to
// receive system notifications
hwnd_controller_ = CreateWindow(class_name_, nullptr, 0, 0, 0, 0, 0, NULL,
NULL, hinstance, this);
}
auto toast = Toast::Get(hwnd);
toast->PopUp(toast_pos);
}
}
HWND DesktopNotificationController::GetToast(
const NotificationData* data) const {
auto it = find_if(instances_.cbegin(), instances_.cend(),
[data](auto&& inst) {
if (!inst.hwnd) return false;
auto toast = Toast::Get(inst.hwnd);
return data == toast->GetNotification().get();
});
auto it =
find_if(instances_.cbegin(), instances_.cend(), [data](auto&& inst) {
if (!inst.hwnd)
return false;
auto toast = Toast::Get(inst.hwnd);
return data == toast->GetNotification().get();
});
return (it != instances_.cend()) ? it->hwnd : NULL;
return (it != instances_.cend()) ? it->hwnd : NULL;
}
void DesktopNotificationController::DestroyToast(ToastInstance& inst) {
if (inst.hwnd) {
auto data = Toast::Get(inst.hwnd)->GetNotification();
if (inst.hwnd) {
auto data = Toast::Get(inst.hwnd)->GetNotification();
DestroyWindow(inst.hwnd);
inst.hwnd = NULL;
DestroyWindow(inst.hwnd);
inst.hwnd = NULL;
Notification notification(data);
OnNotificationClosed(notification);
}
Notification notification(data);
OnNotificationClosed(notification);
}
}
DesktopNotificationController::Notification::Notification(
const shared_ptr<NotificationData>& data) :
data_(data) {
_ASSERT(data != nullptr);
const shared_ptr<NotificationData>& data)
: data_(data) {
_ASSERT(data != nullptr);
}
bool DesktopNotificationController::Notification::operator==(
const Notification& other) const {
return data_ == other.data_;
return data_ == other.data_;
}
void DesktopNotificationController::Notification::Close() {
// No business calling this when not pointing to a valid instance
_ASSERT(data_);
// No business calling this when not pointing to a valid instance
_ASSERT(data_);
if (data_->controller)
data_->controller->CloseNotification(*this);
if (data_->controller)
data_->controller->CloseNotification(*this);
}
void DesktopNotificationController::Notification::Set(
std::wstring caption, std::wstring body_text, HBITMAP image) {
// No business calling this when not pointing to a valid instance
_ASSERT(data_);
void DesktopNotificationController::Notification::Set(std::wstring caption,
std::wstring body_text,
HBITMAP image) {
// No business calling this when not pointing to a valid instance
_ASSERT(data_);
// Do nothing when the notification has been closed
if (!data_->controller)
return;
// Do nothing when the notification has been closed
if (!data_->controller)
return;
if (data_->image) DeleteBitmap(data_->image);
if (data_->image)
DeleteBitmap(data_->image);
data_->caption = move(caption);
data_->body_text = move(body_text);
data_->image = CopyBitmap(image);
data_->caption = move(caption);
data_->body_text = move(body_text);
data_->image = CopyBitmap(image);
auto hwnd = data_->controller->GetToast(data_.get());
if (hwnd) {
auto toast = Toast::Get(hwnd);
toast->ResetContents();
}
auto hwnd = data_->controller->GetToast(data_.get());
if (hwnd) {
auto toast = Toast::Get(hwnd);
toast->ResetContents();
}
// Change of contents can affect size and position of all toasts
data_->controller->StartAnimation();
// Change of contents can affect size and position of all toasts
data_->controller->StartAnimation();
}
DesktopNotificationController::NotificationLink::NotificationLink(
DesktopNotificationController* controller) :
shared_ptr(make_shared<NotificationData>()) {
get()->controller = controller;
DesktopNotificationController* controller)
: shared_ptr(make_shared<NotificationData>()) {
get()->controller = controller;
}
DesktopNotificationController::NotificationLink::~NotificationLink() {
auto p = get();
if (p) p->controller = nullptr;
auto p = get();
if (p)
p->controller = nullptr;
}
} // namespace brightray
} // namespace brightray

128
brightray/browser/win/win32_desktop_notifications/desktop_notification_controller.h
View file

@ -1,9 +1,9 @@
#pragma once
#include <Windows.h>
#include <deque>
#include <memory>
#include <string>
#include <vector>
#include <Windows.h>
namespace brightray {
@ -11,95 +11,95 @@ struct NotificationData;
class DesktopNotificationController {
public:
explicit DesktopNotificationController(unsigned maximum_toasts = 3);
~DesktopNotificationController();
explicit DesktopNotificationController(unsigned maximum_toasts = 3);
~DesktopNotificationController();
class Notification;
Notification AddNotification(std::wstring caption, std::wstring body_text,
HBITMAP image);
void CloseNotification(Notification& notification);
class Notification;
Notification AddNotification(std::wstring caption,
std::wstring body_text,
HBITMAP image);
void CloseNotification(Notification& notification);
// Event handlers -- override to receive the events
// Event handlers -- override to receive the events
private:
virtual void OnNotificationClosed(Notification& notification) {}
virtual void OnNotificationClicked(Notification& notification) {}
virtual void OnNotificationDismissed(Notification& notification) {}
virtual void OnNotificationClosed(Notification& notification) {}
virtual void OnNotificationClicked(Notification& notification) {}
virtual void OnNotificationDismissed(Notification& notification) {}
private:
static HINSTANCE RegisterWndClasses();
void StartAnimation();
HFONT GetCaptionFont();
HFONT GetBodyFont();
static HINSTANCE RegisterWndClasses();
void StartAnimation();
HFONT GetCaptionFont();
HFONT GetBodyFont();
private:
enum TimerID {
TimerID_Animate = 1
};
enum TimerID { TimerID_Animate = 1 };
static constexpr int toast_margin_ = 20;
static constexpr int toast_margin_ = 20;
// Wrapper around `NotificationData` which makes sure that
// the `controller` member is cleared when the controller object
// stops tracking the notification
struct NotificationLink : std::shared_ptr<NotificationData> {
explicit NotificationLink(DesktopNotificationController* controller);
~NotificationLink();
// Wrapper around `NotificationData` which makes sure that
// the `controller` member is cleared when the controller object
// stops tracking the notification
struct NotificationLink : std::shared_ptr<NotificationData> {
explicit NotificationLink(DesktopNotificationController* controller);
~NotificationLink();
NotificationLink(NotificationLink&&) = default;
NotificationLink(const NotificationLink&) = delete;
NotificationLink& operator=(NotificationLink&&) = default;
};
NotificationLink(NotificationLink&&) = default;
NotificationLink(const NotificationLink&) = delete;
NotificationLink& operator=(NotificationLink&&) = default;
};
struct ToastInstance {
HWND hwnd;
NotificationLink data;
};
struct ToastInstance {
HWND hwnd;
NotificationLink data;
};
class Toast;
class Toast;
static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
WPARAM wparam, LPARAM lparam);
static DesktopNotificationController* Get(HWND hwnd) {
return reinterpret_cast<DesktopNotificationController*>(
GetWindowLongPtr(hwnd, 0));
}
static LRESULT CALLBACK WndProc(HWND hwnd,
UINT message,
WPARAM wparam,
LPARAM lparam);
static DesktopNotificationController* Get(HWND hwnd) {
return reinterpret_cast<DesktopNotificationController*>(
GetWindowLongPtr(hwnd, 0));
}
DesktopNotificationController(
const DesktopNotificationController&) = delete;
DesktopNotificationController(const DesktopNotificationController&) = delete;
void InitializeFonts();
void ClearAssets();
void AnimateAll();
void CheckQueue();
void CreateToast(NotificationLink&& data);
HWND GetToast(const NotificationData* data) const;
void DestroyToast(ToastInstance& inst);
void InitializeFonts();
void ClearAssets();
void AnimateAll();
void CheckQueue();
void CreateToast(NotificationLink&& data);
HWND GetToast(const NotificationData* data) const;
void DestroyToast(ToastInstance& inst);
private:
static constexpr const TCHAR class_name_[] =
TEXT("DesktopNotificationController");
static constexpr const TCHAR class_name_[] =
TEXT("DesktopNotificationController");
HWND hwnd_controller_ = NULL;
HFONT caption_font_ = NULL, body_font_ = NULL;
std::vector<ToastInstance> instances_;
std::deque<NotificationLink> queue_;
bool is_animating_ = false;
HWND hwnd_controller_ = NULL;
HFONT caption_font_ = NULL, body_font_ = NULL;
std::vector<ToastInstance> instances_;
std::deque<NotificationLink> queue_;
bool is_animating_ = false;
};
class DesktopNotificationController::Notification {
public:
Notification() = default;
explicit Notification(const std::shared_ptr<NotificationData>& data);
Notification() = default;
explicit Notification(const std::shared_ptr<NotificationData>& data);
bool operator==(const Notification& other) const;
bool operator==(const Notification& other) const;
void Close();
void Set(std::wstring caption, std::wstring body_text, HBITMAP image);
void Close();
void Set(std::wstring caption, std::wstring body_text, HBITMAP image);
private:
std::shared_ptr<NotificationData> data_;
std::shared_ptr<NotificationData> data_;
friend class DesktopNotificationController;
friend class DesktopNotificationController;
};
} // namespace brightray
} // namespace brightray

1252
brightray/browser/win/win32_desktop_notifications/toast.cc
View file

File diff suppressed because it is too large Load diff

135
brightray/browser/win/win32_desktop_notifications/toast.h
View file

@ -5,93 +5,88 @@ namespace brightray {
class DesktopNotificationController::Toast {
public:
static void Register(HINSTANCE hinstance);
static HWND Create(HINSTANCE hinstance,
std::shared_ptr<NotificationData>& data);
static Toast* Get(HWND hwnd) {
return reinterpret_cast<Toast*>(GetWindowLongPtr(hwnd, 0));
}
static void Register(HINSTANCE hinstance);
static HWND Create(HINSTANCE hinstance,
std::shared_ptr<NotificationData>& data);
static Toast* Get(HWND hwnd) {
return reinterpret_cast<Toast*>(GetWindowLongPtr(hwnd, 0));
}
static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
WPARAM wparam, LPARAM lparam);
static LRESULT CALLBACK WndProc(HWND hwnd,
UINT message,
WPARAM wparam,
LPARAM lparam);
const std::shared_ptr<NotificationData>& GetNotification() const {
return data_;
}
const std::shared_ptr<NotificationData>& GetNotification() const {
return data_;
}
void ResetContents();
void ResetContents();
void Dismiss();
void Dismiss();
void PopUp(int y);
void SetVerticalPosition(int y);
int GetVerticalPosition() const {
return vertical_pos_target_;
}
int GetHeight() const {
return toast_size_.cy;
}
HDWP Animate(HDWP hdwp, const POINT& origin);
bool IsAnimationActive() const {
return ease_in_active_ || ease_out_active_ || IsStackCollapseActive();
}
bool IsHighlighted() const {
_ASSERT(!(is_highlighted_ && !IsWindowVisible(hwnd_)));
return is_highlighted_;
}
void PopUp(int y);
void SetVerticalPosition(int y);
int GetVerticalPosition() const { return vertical_pos_target_; }
int GetHeight() const { return toast_size_.cy; }
HDWP Animate(HDWP hdwp, const POINT& origin);
bool IsAnimationActive() const {
return ease_in_active_ || ease_out_active_ || IsStackCollapseActive();
}
bool IsHighlighted() const {
_ASSERT(!(is_highlighted_ && !IsWindowVisible(hwnd_)));
return is_highlighted_;
}
private:
enum TimerID {
TimerID_AutoDismiss = 1
};
enum TimerID { TimerID_AutoDismiss = 1 };
Toast(HWND hwnd, std::shared_ptr<NotificationData>* data);
~Toast();
Toast(HWND hwnd, std::shared_ptr<NotificationData>* data);
~Toast();
void UpdateBufferSize();
void UpdateScaledImage(const SIZE& size);
void Draw();
void Invalidate();
bool IsRedrawNeeded() const;
void UpdateContents();
void UpdateBufferSize();
void UpdateScaledImage(const SIZE& size);
void Draw();
void Invalidate();
bool IsRedrawNeeded() const;
void UpdateContents();
void AutoDismiss();
void CancelDismiss();
void ScheduleDismissal();
void AutoDismiss();
void CancelDismiss();
void ScheduleDismissal();
void StartEaseIn();
void StartEaseOut();
bool IsStackCollapseActive() const;
void StartEaseIn();
void StartEaseOut();
bool IsStackCollapseActive() const;
float AnimateEaseIn();
float AnimateEaseOut();
float AnimateStackCollapse();
float AnimateEaseIn();
float AnimateEaseOut();
float AnimateStackCollapse();
private:
static constexpr const TCHAR class_name_[] =
TEXT("DesktopNotificationToast");
static constexpr const TCHAR class_name_[] = TEXT("DesktopNotificationToast");
const HWND hwnd_;
HDC hdc_;
HBITMAP bitmap_ = NULL;
const HWND hwnd_;
HDC hdc_;
HBITMAP bitmap_ = NULL;
const std::shared_ptr<NotificationData> data_; // never null
const std::shared_ptr<NotificationData> data_; // never null
SIZE toast_size_ = {};
SIZE margin_ = {};
RECT close_button_rect_ = {};
HBITMAP scaled_image_ = NULL;
SIZE toast_size_ = {};
SIZE margin_ = {};
RECT close_button_rect_ = {};
HBITMAP scaled_image_ = NULL;
int vertical_pos_ = 0;
int vertical_pos_target_ = 0;
bool is_non_interactive_ = false;
bool ease_in_active_ = false;
bool ease_out_active_ = false;
bool is_content_updated_ = false;
bool is_highlighted_ = false;
bool is_close_hot_ = false;
DWORD ease_in_start_, ease_out_start_, stack_collapse_start_;
float ease_in_pos_ = 0, ease_out_pos_ = 0, stack_collapse_pos_ = 0;
int vertical_pos_ = 0;
int vertical_pos_target_ = 0;
bool is_non_interactive_ = false;
bool ease_in_active_ = false;
bool ease_out_active_ = false;
bool is_content_updated_ = false;
bool is_highlighted_ = false;
bool is_close_hot_ = false;
DWORD ease_in_start_, ease_out_start_, stack_collapse_start_;
float ease_in_pos_ = 0, ease_out_pos_ = 0, stack_collapse_pos_ = 0;
};
} // namespace brightray
} // namespace brightray

68
brightray/browser/win/win32_notification.cc
View file

@ -11,50 +11,50 @@
namespace brightray {
void Win32Notification::Show(const NotificationOptions& options) {
auto presenter = static_cast<NotificationPresenterWin7*>(this->presenter());
if (!presenter) return;
auto presenter = static_cast<NotificationPresenterWin7*>(this->presenter());
if (!presenter)
return;
HBITMAP image = NULL;
HBITMAP image = NULL;
if (!options.icon.drawsNothing()) {
if (options.icon.colorType() == kBGRA_8888_SkColorType) {
BITMAPINFOHEADER bmi = { sizeof(BITMAPINFOHEADER) };
bmi.biWidth = options.icon.width();
bmi.biHeight = -options.icon.height();
bmi.biPlanes = 1;
bmi.biBitCount = 32;
bmi.biCompression = BI_RGB;
if (!options.icon.drawsNothing()) {
if (options.icon.colorType() == kBGRA_8888_SkColorType) {
BITMAPINFOHEADER bmi = {sizeof(BITMAPINFOHEADER)};
bmi.biWidth = options.icon.width();
bmi.biHeight = -options.icon.height();
bmi.biPlanes = 1;
bmi.biBitCount = 32;
bmi.biCompression = BI_RGB;
HDC hdcScreen = GetDC(NULL);
image = CreateDIBitmap(hdcScreen, &bmi, CBM_INIT,
options.icon.getPixels(),
reinterpret_cast<BITMAPINFO*>(&bmi),
DIB_RGB_COLORS);
ReleaseDC(NULL, hdcScreen);
}
HDC hdcScreen = GetDC(NULL);
image =
CreateDIBitmap(hdcScreen, &bmi, CBM_INIT, options.icon.getPixels(),
reinterpret_cast<BITMAPINFO*>(&bmi), DIB_RGB_COLORS);
ReleaseDC(NULL, hdcScreen);
}
}
Win32Notification* existing = nullptr;
if (!options.tag.empty())
existing = presenter->GetNotificationObjectByTag(options.tag);
Win32Notification* existing = nullptr;
if (!options.tag.empty())
existing = presenter->GetNotificationObjectByTag(options.tag);
if (existing) {
existing->tag_.clear();
this->notification_ref_ = std::move(existing->notification_ref_);
this->notification_ref_.Set(options.title, options.msg, image);
} else {
this->notification_ref_ = presenter->AddNotification(options.title,
options.msg,
image);
}
if (existing) {
existing->tag_.clear();
this->notification_ref_ = std::move(existing->notification_ref_);
this->notification_ref_.Set(options.title, options.msg, image);
} else {
this->notification_ref_ =
presenter->AddNotification(options.title, options.msg, image);
}
this->tag_ = options.tag;
this->tag_ = options.tag;
if (image) DeleteObject(image);
if (image)
DeleteObject(image);
}
void Win32Notification::Dismiss() {
notification_ref_.Close();
notification_ref_.Close();
}
} // namespace brightray
} // namespace brightray

29
brightray/browser/win/win32_notification.h
View file

@ -6,26 +6,23 @@ namespace brightray {
class Win32Notification : public brightray::Notification {
public:
Win32Notification(NotificationDelegate* delegate,
NotificationPresenterWin7* presenter) :
Notification(delegate, presenter) {
}
void Show(const NotificationOptions& options) override;
void Dismiss() override;
Win32Notification(NotificationDelegate* delegate,
NotificationPresenterWin7* presenter)
: Notification(delegate, presenter) {}
void Show(const NotificationOptions& options) override;
void Dismiss() override;
const DesktopNotificationController::Notification& GetRef() const {
return notification_ref_;
}
const DesktopNotificationController::Notification& GetRef() const {
return notification_ref_;
}
const std::string& GetTag() const {
return tag_;
}
const std::string& GetTag() const { return tag_; }
private:
DesktopNotificationController::Notification notification_ref_;
std::string tag_;
DesktopNotificationController::Notification notification_ref_;
std::string tag_;
DISALLOW_COPY_AND_ASSIGN(Win32Notification);
DISALLOW_COPY_AND_ASSIGN(Win32Notification);
};
} // namespace brightray
} // namespace brightray

20
brightray/browser/win/windows_toast_notification.cc
View file

@ -81,9 +81,8 @@ WindowsToastNotification::~WindowsToastNotification() {
void WindowsToastNotification::Show(const NotificationOptions& options) {
auto presenter_win = static_cast<NotificationPresenterWin*>(presenter());
std::wstring icon_path = presenter_win->SaveIconToFilesystem(
options.icon,
options.icon_url);
std::wstring icon_path =
presenter_win->SaveIconToFilesystem(options.icon, options.icon_url);
ComPtr<IXmlDocument> toast_xml;
if (FAILED(GetToastXml(toast_manager_.Get(), options.title, options.msg,
@ -123,14 +122,16 @@ void WindowsToastNotification::Show(const NotificationOptions& options) {
return;
}
if (IsDebuggingNotifications()) LOG(INFO) << "Notification created";
if (IsDebuggingNotifications())
LOG(INFO) << "Notification created";
if (delegate())
delegate()->NotificationDisplayed();
}
void WindowsToastNotification::Dismiss() {
if (IsDebuggingNotifications()) LOG(INFO) << "Hiding notification";
if (IsDebuggingNotifications())
LOG(INFO) << "Hiding notification";
toast_notifier_->Hide(toast_notification_.Get());
}
@ -407,7 +408,8 @@ IFACEMETHODIMP ToastEventHandler::Invoke(
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&Notification::NotificationClicked, notification_));
if (IsDebuggingNotifications()) LOG(INFO) << "Notification clicked";
if (IsDebuggingNotifications())
LOG(INFO) << "Notification clicked";
return S_OK;
}
@ -418,7 +420,8 @@ IFACEMETHODIMP ToastEventHandler::Invoke(
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&Notification::NotificationDismissed, notification_));
if (IsDebuggingNotifications()) LOG(INFO) << "Notification dismissed";
if (IsDebuggingNotifications())
LOG(INFO) << "Notification dismissed";
return S_OK;
}
@ -429,7 +432,8 @@ IFACEMETHODIMP ToastEventHandler::Invoke(
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&Notification::NotificationFailed, notification_));
if (IsDebuggingNotifications()) LOG(INFO) << "Notification failed";
if (IsDebuggingNotifications())
LOG(INFO) << "Notification failed";
return S_OK;
}

3
brightray/common/application_info_win.cc
View file

@ -17,7 +17,6 @@ namespace brightray {
namespace {
base::string16 g_app_user_model_id;
}
const wchar_t kAppUserModelIDFormat[] = L"electron.app.$1";
@ -49,7 +48,7 @@ PCWSTR GetRawAppUserModelID() {
} else {
std::string name = GetApplicationName();
base::string16 generated_app_id = base::ReplaceStringPlaceholders(
kAppUserModelIDFormat, base::UTF8ToUTF16(name), nullptr);
kAppUserModelIDFormat, base::UTF8ToUTF16(name), nullptr);
SetAppUserModelID(generated_app_id);
}
CoTaskMemFree(current_app_id);

13
brightray/common/content_client.cc
View file

@ -16,19 +16,17 @@ namespace brightray {
std::string GetProductInternal() {
auto name = GetApplicationName();
base::RemoveChars(name, base::kWhitespaceASCII, &name);
return base::StringPrintf("%s/%s",
name.c_str(), GetApplicationVersion().c_str());
return base::StringPrintf("%s/%s", name.c_str(),
GetApplicationVersion().c_str());
}
std::string GetBrightrayUserAgent() {
return content::BuildUserAgentFromProduct(GetProductInternal());
}
ContentClient::ContentClient() {
}
ContentClient::ContentClient() {}
ContentClient::~ContentClient() {
}
ContentClient::~ContentClient() {}
std::string ContentClient::GetProduct() const {
return GetProductInternal();
@ -43,7 +41,8 @@ base::string16 ContentClient::GetLocalizedString(int message_id) const {
}
base::StringPiece ContentClient::GetDataResource(
int resource_id, ui::ScaleFactor scale_factor) const {
int resource_id,
ui::ScaleFactor scale_factor) const {
return ui::ResourceBundle::GetSharedInstance().GetRawDataResourceForScale(
resource_id, scale_factor);
}

12
brightray/common/main_delegate.cc
View file

@ -27,8 +27,8 @@ bool SubprocessNeedsResourceBundle(const std::string& process_type) {
process_type == switches::kZygoteProcess ||
#endif
#if defined(OS_MACOSX)
// Mac needs them too for scrollbar related images and for sandbox
// profiles.
// Mac needs them too for scrollbar related images and for sandbox
// profiles.
#if !defined(DISABLE_NACL)
process_type == switches::kNaClLoaderProcess ||
#endif
@ -48,7 +48,7 @@ void LoadResourceBundle(const std::string& locale) {
ui::ResourceBundle::CleanupSharedInstance();
ui::ResourceBundle::InitSharedInstanceWithLocale(
locale, nullptr, ui::ResourceBundle::DO_NOT_LOAD_COMMON_RESOURCES);
locale, nullptr, ui::ResourceBundle::DO_NOT_LOAD_COMMON_RESOURCES);
ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
bundle.ReloadLocaleResources(locale);
@ -82,11 +82,9 @@ void LoadResourceBundle(const std::string& locale) {
#endif
}
MainDelegate::MainDelegate() {
}
MainDelegate::MainDelegate() {}
MainDelegate::~MainDelegate() {
}
MainDelegate::~MainDelegate() {}
std::unique_ptr<ContentClient> MainDelegate::CreateContentClient() {
return std::unique_ptr<ContentClient>(new ContentClient);