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

clang-format brightray

brightray/browser/brightray_paths.h

@@ -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.

brightray/browser/browser_client.cc

@@ -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_) {

brightray/browser/browser_context.cc

@@ -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();
 }
 

brightray/browser/browser_context.h

@@ -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();

brightray/browser/browser_main_parts.cc

@@ -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>();

brightray/browser/devtools_contents_resizing_strategy.cc

@@ -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;
   }
 

brightray/browser/devtools_contents_resizing_strategy.h

@@ -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);

brightray/browser/devtools_embedder_message_dispatcher.cc

@@ -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);

brightray/browser/devtools_embedder_message_dispatcher.h

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

brightray/browser/devtools_file_system_indexer.cc

@@ -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(

brightray/browser/devtools_file_system_indexer.h

@@ -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);

brightray/browser/devtools_manager_delegate.cc

@@ -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(

brightray/browser/devtools_manager_delegate.h

@@ -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;

brightray/browser/devtools_ui.cc

@@ -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) {

brightray/browser/inspectable_web_contents_delegate.h

@@ -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

brightray/browser/inspectable_web_contents_impl.cc

@@ -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

brightray/browser/inspectable_web_contents_impl.h

@@ -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_;

brightray/browser/inspectable_web_contents_view.h

@@ -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.

brightray/browser/inspectable_web_contents_view_delegate.cc

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

brightray/browser/inspectable_web_contents_view_delegate.h

@@ -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
 };
 

brightray/browser/io_thread.h

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

brightray/browser/linux/libnotify_loader.cc

@@ -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;

brightray/browser/linux/libnotify_notification.cc

@@ -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();
 }
 

brightray/browser/linux/libnotify_notification.h

@@ -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_;
 

brightray/browser/linux/notification_presenter_linux.cc

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

brightray/browser/mac/bry_inspectable_web_contents_view.h

@@ -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

brightray/browser/mac/notification_center_delegate.h

@@ -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_

brightray/browser/media/media_capture_devices_dispatcher.cc

@@ -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

brightray/browser/media/media_capture_devices_dispatcher.h

@@ -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,

brightray/browser/media/media_stream_devices_controller.cc

@@ -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>());
 }
 

brightray/browser/net_log.cc

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

brightray/browser/network_delegate.cc

@@ -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;
 }
 

brightray/browser/network_delegate.h

@@ -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,

brightray/browser/notification.cc

@@ -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())

brightray/browser/notification_presenter.cc

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

brightray/browser/permission_manager.cc

@@ -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,

brightray/browser/platform_notification_service.cc

@@ -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

brightray/browser/special_storage_policy.cc

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

brightray/browser/url_request_context_getter.cc

@@ -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);

brightray/browser/url_request_context_getter.h

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

brightray/browser/views/inspectable_web_contents_view_views.cc

@@ -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.

brightray/browser/views/inspectable_web_contents_view_views.h

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

brightray/browser/views/views_delegate.cc

@@ -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 {

brightray/browser/views/views_delegate.h

@@ -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,

brightray/browser/web_ui_controller_factory.cc

@@ -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);

brightray/browser/web_ui_controller_factory.h

@@ -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,

brightray/browser/win/notification_presenter_win.cc

@@ -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()) {

brightray/browser/win/notification_presenter_win7.cc

@@ -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

brightray/browser/win/notification_presenter_win7.h

@@ -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

brightray/browser/win/scoped_hstring.cc

@@ -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();

brightray/browser/win/win32_desktop_notifications/common.h

@@ -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;
-
-    ScreenMetrics() {
-        typedef HRESULT WINAPI GetDpiForMonitor_t(HMONITOR, int, UINT*, UINT*);
+  UINT dpi_x, dpi_y;
 
-        auto GetDpiForMonitor = reinterpret_cast<GetDpiForMonitor_t*>(
-            GetProcAddress(GetModuleHandle(TEXT("shcore")),
-                           "GetDpiForMonitor"));
+  ScreenMetrics() {
+    typedef HRESULT WINAPI GetDpiForMonitor_t(HMONITOR, int, UINT*, UINT*);
 
-        if (GetDpiForMonitor) {
-            auto monitor = MonitorFromPoint({}, MONITOR_DEFAULTTOPRIMARY);
-            if (GetDpiForMonitor(monitor, 0, &dpi_x, &dpi_y) == S_OK)
-                return;
-        }
+    auto GetDpiForMonitor = reinterpret_cast<GetDpiForMonitor_t*>(
+        GetProcAddress(GetModuleHandle(TEXT("shcore")), "GetDpiForMonitor"));
 
-        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

brightray/browser/win/win32_desktop_notifications/desktop_notification_controller.cc

@@ -13,393 +13,405 @@ using std::shared_ptr;
 namespace brightray {
 
 HBITMAP CopyBitmap(HBITMAP bitmap) {
-    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);
-
-        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);
-        }
+  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);
+
+    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;
-
-    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;
-
-            RegisterClassEx(&wc);
-        }
+  // 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);
+
+      WNDCLASSEX wc = {sizeof(wc)};
+      wc.lpfnWndProc = &WndProc;
+      wc.lpszClassName = class_name_;
+      wc.cbWndExtra = sizeof(DesktopNotificationController*);
+      wc.hInstance = module;
+
+      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;
-
-    case WM_DISPLAYCHANGE:
-        {
-            auto inst = Get(hwnd);
-            inst->ClearAssets();
-            inst->AnimateAll();
-        }
-        break;
+      if (wparam == TimerID_Animate) {
+        Get(hwnd)->AnimateAll();
+      }
+      return 0;
+
+    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;
-
-            HDC hdc = GetDC(NULL);
-            auto base_dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
-            ReleaseDC(NULL, hdc);
-
-            ScreenMetrics scr;
-
-            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 (!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);
+
+      ScreenMetrics scr;
+
+      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);
     }
+  }
 }
 
 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.
-
-    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_) };
-
-            auto hdwp =
-                BeginDeferWindowPos(static_cast<int>(instances_.size()));
-
-            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();
-            }
-
-            if (hdwp) EndDeferWindowPos(hdwp);
-        }
-    }
-
-    if (!keep_animating) {
-        _ASSERT(hwnd_controller_);
-        if (hwnd_controller_) KillTimer(hwnd_controller_, TimerID_Animate);
-        is_animating_ = false;
+  // 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;
+
+  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()));
+
+      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();
+      }
+
+      if (hdwp)
+        EndDeferWindowPos(hdwp);
     }
+  }
 
-    // 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);
+  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;
+      }
 
-            // collapse the stack in front of the highlighted item
-            it = stable_partition(it, it2, is_alive);
+      it = move(it2);
+    }
+  }
 
-            // purge the dead items
-            for_each(it, it2, [this](auto&& inst) { DestroyToast(inst); });
+  // Set new toast positions
+  if (!instances_.empty()) {
+    ScreenMetrics metrics;
+    auto margin = metrics.Y(toast_margin_);
 
-            if (it2 == instances_.end()) {
-                instances_.erase(it, it2);
-                break;
-            }
+    int target_pos = 0;
+    for (auto&& inst : instances_) {
+      if (inst.hwnd) {
+        auto toast = Toast::Get(inst.hwnd);
 
-            it = move(it2);
-        }
-    }
+        if (toast->IsHighlighted())
+          target_pos = toast->GetVerticalPosition();
+        else
+          toast->SetVerticalPosition(target_pos);
 
-    // 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;
-            }
-        }
+        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);
-
-    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;
+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);
+
+  // 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;
-    }
-
-    // Dismiss active toast
-    auto hwnd = GetToast(notification.data_.get());
-    if (hwnd) {
-        auto toast = Toast::Get(hwnd);
-        toast->Dismiss();
-    }
+  // 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();
+  }
 }
 
 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);
-
-            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);
+  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);
+  }
 }
 
 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();
-        });
-
-    return (it != instances_.cend()) ? it->hwnd : NULL;
+  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;
 }
 
 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

brightray/browser/win/win32_desktop_notifications/desktop_notification_controller.h

@@ -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
-    };
-
-    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();
-
-        NotificationLink(NotificationLink&&) = default;
-        NotificationLink(const NotificationLink&) = delete;
-        NotificationLink& operator=(NotificationLink&&) = default;
-    };
-
-    struct ToastInstance {
-        HWND hwnd;
-        NotificationLink data;
-    };
-
-    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));
-    }
-
-    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);
+  enum TimerID { TimerID_Animate = 1 };
+
+  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();
+
+    NotificationLink(NotificationLink&&) = default;
+    NotificationLink(const NotificationLink&) = delete;
+    NotificationLink& operator=(NotificationLink&&) = default;
+  };
+
+  struct ToastInstance {
+    HWND hwnd;
+    NotificationLink data;
+  };
+
+  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));
+  }
+
+  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);
 
  private:
-    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;
+  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;
 };
 
 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

brightray/browser/win/win32_desktop_notifications/toast.cc

@@ -14,813 +14,791 @@ using std::shared_ptr;
 namespace brightray {
 
 static COLORREF GetAccentColor() {
-    bool success = false;
-    if (IsAppThemed()) {
-        HKEY hkey;
-        if (RegOpenKeyEx(HKEY_CURRENT_USER,
-                         TEXT("SOFTWARE\\Microsoft\\Windows\\DWM"), 0,
-                         KEY_QUERY_VALUE, &hkey) == ERROR_SUCCESS) {
-            COLORREF color;
-            DWORD type, size;
-            if (RegQueryValueEx(hkey, TEXT("AccentColor"), nullptr,
-                                &type,
-                                reinterpret_cast<BYTE*>(&color),
-                                &(size = sizeof(color))) == ERROR_SUCCESS &&
-                type == REG_DWORD) {
-                // convert from RGBA
-                color = RGB(GetRValue(color),
-                            GetGValue(color),
-                            GetBValue(color));
-                success = true;
-            } else if (
-                RegQueryValueEx(hkey, TEXT("ColorizationColor"), nullptr,
-                                &type,
-                                reinterpret_cast<BYTE*>(&color),
-                                &(size = sizeof(color))) == ERROR_SUCCESS &&
-                type == REG_DWORD) {
-                // convert from BGRA
-                color = RGB(GetBValue(color),
-                            GetGValue(color),
-                            GetRValue(color));
-                success = true;
-            }
-
-            RegCloseKey(hkey);
-
-            if (success) return color;
-        }
+  bool success = false;
+  if (IsAppThemed()) {
+    HKEY hkey;
+    if (RegOpenKeyEx(HKEY_CURRENT_USER,
+                     TEXT("SOFTWARE\\Microsoft\\Windows\\DWM"), 0,
+                     KEY_QUERY_VALUE, &hkey) == ERROR_SUCCESS) {
+      COLORREF color;
+      DWORD type, size;
+      if (RegQueryValueEx(hkey, TEXT("AccentColor"), nullptr, &type,
+                          reinterpret_cast<BYTE*>(&color),
+                          &(size = sizeof(color))) == ERROR_SUCCESS &&
+          type == REG_DWORD) {
+        // convert from RGBA
+        color = RGB(GetRValue(color), GetGValue(color), GetBValue(color));
+        success = true;
+      } else if (RegQueryValueEx(hkey, TEXT("ColorizationColor"), nullptr,
+                                 &type, reinterpret_cast<BYTE*>(&color),
+                                 &(size = sizeof(color))) == ERROR_SUCCESS &&
+                 type == REG_DWORD) {
+        // convert from BGRA
+        color = RGB(GetBValue(color), GetGValue(color), GetRValue(color));
+        success = true;
+      }
+
+      RegCloseKey(hkey);
+
+      if (success)
+        return color;
     }
+  }
 
-    return GetSysColor(COLOR_ACTIVECAPTION);
+  return GetSysColor(COLOR_ACTIVECAPTION);
 }
 
 // Stretches a bitmap to the specified size, preserves alpha channel
 static HBITMAP StretchBitmap(HBITMAP bitmap, unsigned width, unsigned height) {
-    // We use StretchBlt for the scaling, but that discards the alpha channel.
-    // So we first create a separate grayscale bitmap from the alpha channel,
-    // scale that separately, and copy it back to the scaled color bitmap.
+  // We use StretchBlt for the scaling, but that discards the alpha channel.
+  // So we first create a separate grayscale bitmap from the alpha channel,
+  // scale that separately, and copy it back to the scaled color bitmap.
 
-    BITMAP bm;
-    if (!GetObject(bitmap, sizeof(bm), &bm))
-        return NULL;
+  BITMAP bm;
+  if (!GetObject(bitmap, sizeof(bm), &bm))
+    return NULL;
 
-    if (width == 0 || height == 0)
-        return NULL;
+  if (width == 0 || height == 0)
+    return NULL;
 
-    HBITMAP result_bitmap = NULL;
+  HBITMAP result_bitmap = NULL;
 
-    HDC hdc_screen = GetDC(NULL);
+  HDC hdc_screen = GetDC(NULL);
 
-    HBITMAP alpha_src_bitmap;
-    {
-        BITMAPINFOHEADER bmi = { sizeof(BITMAPINFOHEADER) };
-        bmi.biWidth = bm.bmWidth;
-        bmi.biHeight = bm.bmHeight;
-        bmi.biPlanes = bm.bmPlanes;
-        bmi.biBitCount = bm.bmBitsPixel;
-        bmi.biCompression = BI_RGB;
-
-        void* alpha_src_bits;
-        alpha_src_bitmap =
-            CreateDIBSection(NULL, reinterpret_cast<BITMAPINFO*>(&bmi),
-                             DIB_RGB_COLORS, &alpha_src_bits, NULL, 0);
-
-        if (alpha_src_bitmap) {
-            if (GetDIBits(hdc_screen, bitmap, 0, 0, 0,
-                          reinterpret_cast<BITMAPINFO*>(&bmi),
-                          DIB_RGB_COLORS) &&
-                bmi.biSizeImage > 0 &&
-                (bmi.biSizeImage % 4) == 0) {
-                auto buf = reinterpret_cast<BYTE*>(
-                    _aligned_malloc(bmi.biSizeImage, sizeof(DWORD)));
-
-                if (buf) {
-                    GetDIBits(hdc_screen, bitmap, 0, bm.bmHeight, buf,
-                              reinterpret_cast<BITMAPINFO*>(&bmi),
-                              DIB_RGB_COLORS);
-
-                    const DWORD *src = reinterpret_cast<DWORD*>(buf);
-                    const DWORD *end =
-                        reinterpret_cast<DWORD*>(buf + bmi.biSizeImage);
-
-                    BYTE* dest = reinterpret_cast<BYTE*>(alpha_src_bits);
-
-                    for (; src != end; ++src, ++dest) {
-                        BYTE a = *src >> 24;
-                        *dest++ = a;
-                        *dest++ = a;
-                        *dest++ = a;
-                    }
-
-                    _aligned_free(buf);
-                }
-            }
-        }
-    }
+  HBITMAP alpha_src_bitmap;
+  {
+    BITMAPINFOHEADER bmi = {sizeof(BITMAPINFOHEADER)};
+    bmi.biWidth = bm.bmWidth;
+    bmi.biHeight = bm.bmHeight;
+    bmi.biPlanes = bm.bmPlanes;
+    bmi.biBitCount = bm.bmBitsPixel;
+    bmi.biCompression = BI_RGB;
+
+    void* alpha_src_bits;
+    alpha_src_bitmap =
+        CreateDIBSection(NULL, reinterpret_cast<BITMAPINFO*>(&bmi),
+                         DIB_RGB_COLORS, &alpha_src_bits, NULL, 0);
 
     if (alpha_src_bitmap) {
-        BITMAPINFOHEADER bmi = { sizeof(BITMAPINFOHEADER) };
-        bmi.biWidth = width;
-        bmi.biHeight = height;
-        bmi.biPlanes = 1;
-        bmi.biBitCount = 32;
-        bmi.biCompression = BI_RGB;
-
-        void* color_bits;
-        auto color_bitmap =
-            CreateDIBSection(NULL, reinterpret_cast<BITMAPINFO*>(&bmi),
-                             DIB_RGB_COLORS, &color_bits, NULL, 0);
-
-        void* alpha_bits;
-        auto alpha_bitmap =
-            CreateDIBSection(NULL, reinterpret_cast<BITMAPINFO*>(&bmi),
-                             DIB_RGB_COLORS, &alpha_bits, NULL, 0);
-
-        HDC hdc = CreateCompatibleDC(NULL);
-        HDC hdc_src = CreateCompatibleDC(NULL);
-
-        if (color_bitmap && alpha_bitmap && hdc && hdc_src) {
-            SetStretchBltMode(hdc, HALFTONE);
-
-            // resize color channels
-            SelectObject(hdc, color_bitmap);
-            SelectObject(hdc_src, bitmap);
-            StretchBlt(hdc, 0, 0, width, height,
-                       hdc_src, 0, 0, bm.bmWidth, bm.bmHeight,
-                       SRCCOPY);
-
-            // resize alpha channel
-            SelectObject(hdc, alpha_bitmap);
-            SelectObject(hdc_src, alpha_src_bitmap);
-            StretchBlt(hdc, 0, 0, width, height,
-                       hdc_src, 0, 0, bm.bmWidth, bm.bmHeight,
-                       SRCCOPY);
-
-            // flush before touching the bits
-            GdiFlush();
-
-            // apply the alpha channel
-            auto dest = reinterpret_cast<BYTE*>(color_bits);
-            auto src = reinterpret_cast<const BYTE*>(alpha_bits);
-            auto end = src + (width * height * 4);
-            while (src != end) {
-                dest[3] = src[0];
-                dest += 4;
-                src += 4;
-            }
+      if (GetDIBits(hdc_screen, bitmap, 0, 0, 0,
+                    reinterpret_cast<BITMAPINFO*>(&bmi), DIB_RGB_COLORS) &&
+          bmi.biSizeImage > 0 && (bmi.biSizeImage % 4) == 0) {
+        auto buf = reinterpret_cast<BYTE*>(
+            _aligned_malloc(bmi.biSizeImage, sizeof(DWORD)));
 
-            // create the resulting bitmap
-            result_bitmap = CreateDIBitmap(hdc_screen, &bmi, CBM_INIT,
-                                           color_bits,
-                                           reinterpret_cast<BITMAPINFO*>(&bmi),
-                                           DIB_RGB_COLORS);
-        }
+        if (buf) {
+          GetDIBits(hdc_screen, bitmap, 0, bm.bmHeight, buf,
+                    reinterpret_cast<BITMAPINFO*>(&bmi), DIB_RGB_COLORS);
+
+          const DWORD* src = reinterpret_cast<DWORD*>(buf);
+          const DWORD* end = reinterpret_cast<DWORD*>(buf + bmi.biSizeImage);
 
-        if (hdc_src) DeleteDC(hdc_src);
-        if (hdc) DeleteDC(hdc);
+          BYTE* dest = reinterpret_cast<BYTE*>(alpha_src_bits);
 
-        if (alpha_bitmap) DeleteObject(alpha_bitmap);
-        if (color_bitmap) DeleteObject(color_bitmap);
+          for (; src != end; ++src, ++dest) {
+            BYTE a = *src >> 24;
+            *dest++ = a;
+            *dest++ = a;
+            *dest++ = a;
+          }
 
-        DeleteObject(alpha_src_bitmap);
+          _aligned_free(buf);
+        }
+      }
+    }
+  }
+
+  if (alpha_src_bitmap) {
+    BITMAPINFOHEADER bmi = {sizeof(BITMAPINFOHEADER)};
+    bmi.biWidth = width;
+    bmi.biHeight = height;
+    bmi.biPlanes = 1;
+    bmi.biBitCount = 32;
+    bmi.biCompression = BI_RGB;
+
+    void* color_bits;
+    auto color_bitmap =
+        CreateDIBSection(NULL, reinterpret_cast<BITMAPINFO*>(&bmi),
+                         DIB_RGB_COLORS, &color_bits, NULL, 0);
+
+    void* alpha_bits;
+    auto alpha_bitmap =
+        CreateDIBSection(NULL, reinterpret_cast<BITMAPINFO*>(&bmi),
+                         DIB_RGB_COLORS, &alpha_bits, NULL, 0);
+
+    HDC hdc = CreateCompatibleDC(NULL);
+    HDC hdc_src = CreateCompatibleDC(NULL);
+
+    if (color_bitmap && alpha_bitmap && hdc && hdc_src) {
+      SetStretchBltMode(hdc, HALFTONE);
+
+      // resize color channels
+      SelectObject(hdc, color_bitmap);
+      SelectObject(hdc_src, bitmap);
+      StretchBlt(hdc, 0, 0, width, height, hdc_src, 0, 0, bm.bmWidth,
+                 bm.bmHeight, SRCCOPY);
+
+      // resize alpha channel
+      SelectObject(hdc, alpha_bitmap);
+      SelectObject(hdc_src, alpha_src_bitmap);
+      StretchBlt(hdc, 0, 0, width, height, hdc_src, 0, 0, bm.bmWidth,
+                 bm.bmHeight, SRCCOPY);
+
+      // flush before touching the bits
+      GdiFlush();
+
+      // apply the alpha channel
+      auto dest = reinterpret_cast<BYTE*>(color_bits);
+      auto src = reinterpret_cast<const BYTE*>(alpha_bits);
+      auto end = src + (width * height * 4);
+      while (src != end) {
+        dest[3] = src[0];
+        dest += 4;
+        src += 4;
+      }
+
+      // create the resulting bitmap
+      result_bitmap =
+          CreateDIBitmap(hdc_screen, &bmi, CBM_INIT, color_bits,
+                         reinterpret_cast<BITMAPINFO*>(&bmi), DIB_RGB_COLORS);
     }
 
-    ReleaseDC(NULL, hdc_screen);
+    if (hdc_src)
+      DeleteDC(hdc_src);
+    if (hdc)
+      DeleteDC(hdc);
+
+    if (alpha_bitmap)
+      DeleteObject(alpha_bitmap);
+    if (color_bitmap)
+      DeleteObject(color_bitmap);
 
-    return result_bitmap;
+    DeleteObject(alpha_src_bitmap);
+  }
+
+  ReleaseDC(NULL, hdc_screen);
+
+  return result_bitmap;
 }
 
-DesktopNotificationController::Toast::Toast(
-    HWND hwnd, shared_ptr<NotificationData>* data) :
-    hwnd_(hwnd), data_(*data) {
-    HDC hdc_screen = GetDC(NULL);
-    hdc_ = CreateCompatibleDC(hdc_screen);
-    ReleaseDC(NULL, hdc_screen);
+DesktopNotificationController::Toast::Toast(HWND hwnd,
+                                            shared_ptr<NotificationData>* data)
+    : hwnd_(hwnd), data_(*data) {
+  HDC hdc_screen = GetDC(NULL);
+  hdc_ = CreateCompatibleDC(hdc_screen);
+  ReleaseDC(NULL, hdc_screen);
 }
 
 DesktopNotificationController::Toast::~Toast() {
-    DeleteDC(hdc_);
-    if (bitmap_) DeleteBitmap(bitmap_);
-    if (scaled_image_) DeleteBitmap(scaled_image_);
+  DeleteDC(hdc_);
+  if (bitmap_)
+    DeleteBitmap(bitmap_);
+  if (scaled_image_)
+    DeleteBitmap(scaled_image_);
 }
 
 void DesktopNotificationController::Toast::Register(HINSTANCE hinstance) {
-    WNDCLASSEX wc = { sizeof(wc) };
-    wc.lpfnWndProc = &Toast::WndProc;
-    wc.lpszClassName = class_name_;
-    wc.cbWndExtra = sizeof(Toast*);
-    wc.hInstance = hinstance;
-    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
-
-    RegisterClassEx(&wc);
+  WNDCLASSEX wc = {sizeof(wc)};
+  wc.lpfnWndProc = &Toast::WndProc;
+  wc.lpszClassName = class_name_;
+  wc.cbWndExtra = sizeof(Toast*);
+  wc.hInstance = hinstance;
+  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+
+  RegisterClassEx(&wc);
 }
 
-LRESULT DesktopNotificationController::Toast::WndProc(
-    HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
-    switch (message) {
-    case WM_CREATE:
-        {
-            auto& cs = reinterpret_cast<const CREATESTRUCT*&>(lparam);
-            auto data =
-                static_cast<shared_ptr<NotificationData>*>(cs->lpCreateParams);
-            auto inst = new Toast(hwnd, data);
-            SetWindowLongPtr(hwnd, 0, (LONG_PTR)inst);
-        }
-        break;
+LRESULT DesktopNotificationController::Toast::WndProc(HWND hwnd,
+                                                      UINT message,
+                                                      WPARAM wparam,
+                                                      LPARAM lparam) {
+  switch (message) {
+    case WM_CREATE: {
+      auto& cs = reinterpret_cast<const CREATESTRUCT*&>(lparam);
+      auto data =
+          static_cast<shared_ptr<NotificationData>*>(cs->lpCreateParams);
+      auto inst = new Toast(hwnd, data);
+      SetWindowLongPtr(hwnd, 0, (LONG_PTR)inst);
+    } break;
 
     case WM_NCDESTROY:
-        delete Get(hwnd);
-        SetWindowLongPtr(hwnd, 0, 0);
-        return 0;
+      delete Get(hwnd);
+      SetWindowLongPtr(hwnd, 0, 0);
+      return 0;
 
     case WM_MOUSEACTIVATE:
-        return MA_NOACTIVATE;
+      return MA_NOACTIVATE;
 
     case WM_TIMER:
-        if (wparam == TimerID_AutoDismiss) {
-            Get(hwnd)->AutoDismiss();
-        }
-        return 0;
+      if (wparam == TimerID_AutoDismiss) {
+        Get(hwnd)->AutoDismiss();
+      }
+      return 0;
 
-    case WM_LBUTTONDOWN:
-        {
-            auto inst = Get(hwnd);
+    case WM_LBUTTONDOWN: {
+      auto inst = Get(hwnd);
 
-            inst->Dismiss();
+      inst->Dismiss();
 
-            Notification notification(inst->data_);
-            if (inst->is_close_hot_)
-                inst->data_->controller->OnNotificationDismissed(notification);
-            else
-                inst->data_->controller->OnNotificationClicked(notification);
-        }
-        return 0;
+      Notification notification(inst->data_);
+      if (inst->is_close_hot_)
+        inst->data_->controller->OnNotificationDismissed(notification);
+      else
+        inst->data_->controller->OnNotificationClicked(notification);
+    }
+      return 0;
 
-    case WM_MOUSEMOVE:
-        {
-            auto inst = Get(hwnd);
-            if (!inst->is_highlighted_) {
-                inst->is_highlighted_ = true;
+    case WM_MOUSEMOVE: {
+      auto inst = Get(hwnd);
+      if (!inst->is_highlighted_) {
+        inst->is_highlighted_ = true;
 
-                TRACKMOUSEEVENT tme = { sizeof(tme), TME_LEAVE, hwnd };
-                TrackMouseEvent(&tme);
-            }
+        TRACKMOUSEEVENT tme = {sizeof(tme), TME_LEAVE, hwnd};
+        TrackMouseEvent(&tme);
+      }
 
-            POINT cursor = { GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam) };
-            inst->is_close_hot_ =
-                (PtInRect(&inst->close_button_rect_, cursor) != FALSE);
+      POINT cursor = {GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam)};
+      inst->is_close_hot_ =
+          (PtInRect(&inst->close_button_rect_, cursor) != FALSE);
 
-            if (!inst->is_non_interactive_)
-                inst->CancelDismiss();
+      if (!inst->is_non_interactive_)
+        inst->CancelDismiss();
 
-            inst->UpdateContents();
-        }
-        return 0;
+      inst->UpdateContents();
+    }
+      return 0;
 
-    case WM_MOUSELEAVE:
-        {
-            auto inst = Get(hwnd);
-            inst->is_highlighted_ = false;
-            inst->is_close_hot_ = false;
-            inst->UpdateContents();
+    case WM_MOUSELEAVE: {
+      auto inst = Get(hwnd);
+      inst->is_highlighted_ = false;
+      inst->is_close_hot_ = false;
+      inst->UpdateContents();
 
-            if (!inst->ease_out_active_ && inst->ease_in_pos_ == 1.0f)
-                inst->ScheduleDismissal();
+      if (!inst->ease_out_active_ && inst->ease_in_pos_ == 1.0f)
+        inst->ScheduleDismissal();
 
-            // Make sure stack collapse happens if needed
-            inst->data_->controller->StartAnimation();
-        }
-        return 0;
-
-    case WM_WINDOWPOSCHANGED:
-        {
-            auto& wp = reinterpret_cast<WINDOWPOS*&>(lparam);
-            if (wp->flags & SWP_HIDEWINDOW) {
-                if (!IsWindowVisible(hwnd))
-                    Get(hwnd)->is_highlighted_ = false;
-            }
-        }
-        break;
+      // Make sure stack collapse happens if needed
+      inst->data_->controller->StartAnimation();
     }
-
-    return DefWindowProc(hwnd, message, wparam, lparam);
+      return 0;
+
+    case WM_WINDOWPOSCHANGED: {
+      auto& wp = reinterpret_cast<WINDOWPOS*&>(lparam);
+      if (wp->flags & SWP_HIDEWINDOW) {
+        if (!IsWindowVisible(hwnd))
+          Get(hwnd)->is_highlighted_ = false;
+      }
+    } break;
+  }
+
+  return DefWindowProc(hwnd, message, wparam, lparam);
 }
 
 HWND DesktopNotificationController::Toast::Create(
-    HINSTANCE hinstance, shared_ptr<NotificationData>& data) {
-    return CreateWindowEx(WS_EX_LAYERED | WS_EX_NOACTIVATE | WS_EX_TOPMOST,
-                          class_name_, nullptr, WS_POPUP, 0, 0, 0, 0,
-                          NULL, NULL, hinstance, &data);
+    HINSTANCE hinstance,
+    shared_ptr<NotificationData>& data) {
+  return CreateWindowEx(WS_EX_LAYERED | WS_EX_NOACTIVATE | WS_EX_TOPMOST,
+                        class_name_, nullptr, WS_POPUP, 0, 0, 0, 0, NULL, NULL,
+                        hinstance, &data);
 }
 
 void DesktopNotificationController::Toast::Draw() {
-    const COLORREF accent = GetAccentColor();
-
-    COLORREF back_color;
-    {
-        // base background color is 2/3 of accent
-        // highlighted adds a bit of intensity to every channel
-
-        int h = is_highlighted_ ? (0xff / 20) : 0;
-
-        back_color = RGB(min(0xff, (GetRValue(accent) * 2 / 3) + h),
-                         min(0xff, (GetGValue(accent) * 2 / 3) + h),
-                         min(0xff, (GetBValue(accent) * 2 / 3) + h));
-    }
-
-    const float back_luma =
-        (GetRValue(back_color) * 0.299f / 255) +
-        (GetGValue(back_color) * 0.587f / 255) +
-        (GetBValue(back_color) * 0.114f / 255);
-
-    const struct { float r, g, b; } back_f = {
-        GetRValue(back_color) / 255.0f,
-        GetGValue(back_color) / 255.0f,
-        GetBValue(back_color) / 255.0f,
-    };
-
-    COLORREF fore_color, dimmed_color;
-    {
-        // based on the lightness of background, we draw foreground in light
-        // or dark shades of gray blended onto the background with slight
-        // transparency to avoid sharp contrast
-
-        constexpr float alpha = 0.9f;
-        constexpr float intensity_light[] = { (1.0f * alpha), (0.8f * alpha) };
-        constexpr float intensity_dark[] = { (0.1f * alpha), (0.3f * alpha) };
-
-        // select foreground intensity values (light or dark)
-        auto& i = (back_luma < 0.6f) ? intensity_light : intensity_dark;
-
-        float r, g, b;
-
-        r = i[0] + back_f.r * (1 - alpha);
-        g = i[0] + back_f.g * (1 - alpha);
-        b = i[0] + back_f.b * (1 - alpha);
-        fore_color = RGB(r * 0xff, g * 0xff, b * 0xff);
-
-        r = i[1] + back_f.r * (1 - alpha);
-        g = i[1] + back_f.g * (1 - alpha);
-        b = i[1] + back_f.b * (1 - alpha);
-        dimmed_color = RGB(r * 0xff, g * 0xff, b * 0xff);
-    }
-
-    // Draw background
-    {
-        auto brush = CreateSolidBrush(back_color);
-
-        RECT rc = { 0, 0, toast_size_.cx, toast_size_.cy };
-        FillRect(hdc_, &rc, brush);
+  const COLORREF accent = GetAccentColor();
 
-        DeleteBrush(brush);
-    }
-
-    SetBkMode(hdc_, TRANSPARENT);
-
-    const auto close = L'\x2715';
-    auto caption_font = data_->controller->GetCaptionFont();
-    auto body_font = data_->controller->GetBodyFont();
+  COLORREF back_color;
+  {
+    // base background color is 2/3 of accent
+    // highlighted adds a bit of intensity to every channel
+
+    int h = is_highlighted_ ? (0xff / 20) : 0;
+
+    back_color = RGB(min(0xff, (GetRValue(accent) * 2 / 3) + h),
+                     min(0xff, (GetGValue(accent) * 2 / 3) + h),
+                     min(0xff, (GetBValue(accent) * 2 / 3) + h));
+  }
+
+  const float back_luma = (GetRValue(back_color) * 0.299f / 255) +
+                          (GetGValue(back_color) * 0.587f / 255) +
+                          (GetBValue(back_color) * 0.114f / 255);
+
+  const struct {
+    float r, g, b;
+  } back_f = {
+      GetRValue(back_color) / 255.0f,
+      GetGValue(back_color) / 255.0f,
+      GetBValue(back_color) / 255.0f,
+  };
+
+  COLORREF fore_color, dimmed_color;
+  {
+    // based on the lightness of background, we draw foreground in light
+    // or dark shades of gray blended onto the background with slight
+    // transparency to avoid sharp contrast
+
+    constexpr float alpha = 0.9f;
+    constexpr float intensity_light[] = {(1.0f * alpha), (0.8f * alpha)};
+    constexpr float intensity_dark[] = {(0.1f * alpha), (0.3f * alpha)};
+
+    // select foreground intensity values (light or dark)
+    auto& i = (back_luma < 0.6f) ? intensity_light : intensity_dark;
+
+    float r, g, b;
+
+    r = i[0] + back_f.r * (1 - alpha);
+    g = i[0] + back_f.g * (1 - alpha);
+    b = i[0] + back_f.b * (1 - alpha);
+    fore_color = RGB(r * 0xff, g * 0xff, b * 0xff);
+
+    r = i[1] + back_f.r * (1 - alpha);
+    g = i[1] + back_f.g * (1 - alpha);
+    b = i[1] + back_f.b * (1 - alpha);
+    dimmed_color = RGB(r * 0xff, g * 0xff, b * 0xff);
+  }
+
+  // Draw background
+  {
+    auto brush = CreateSolidBrush(back_color);
+
+    RECT rc = {0, 0, toast_size_.cx, toast_size_.cy};
+    FillRect(hdc_, &rc, brush);
+
+    DeleteBrush(brush);
+  }
+
+  SetBkMode(hdc_, TRANSPARENT);
+
+  const auto close = L'\x2715';
+  auto caption_font = data_->controller->GetCaptionFont();
+  auto body_font = data_->controller->GetBodyFont();
+
+  TEXTMETRIC tm_cap;
+  SelectFont(hdc_, caption_font);
+  GetTextMetrics(hdc_, &tm_cap);
+
+  auto text_offset_x = margin_.cx;
+
+  BITMAP image_info = {};
+  if (scaled_image_) {
+    GetObject(scaled_image_, sizeof(image_info), &image_info);
+
+    text_offset_x += margin_.cx + image_info.bmWidth;
+  }
+
+  // calculate close button rect
+  POINT close_pos;
+  {
+    SIZE extent = {};
+    GetTextExtentPoint32W(hdc_, &close, 1, &extent);
+
+    close_button_rect_.right = toast_size_.cx;
+    close_button_rect_.top = 0;
+
+    close_pos.x = close_button_rect_.right - margin_.cy - extent.cx;
+    close_pos.y = close_button_rect_.top + margin_.cy;
+
+    close_button_rect_.left = close_pos.x - margin_.cy;
+    close_button_rect_.bottom = close_pos.y + extent.cy + margin_.cy;
+  }
+
+  // image
+  if (scaled_image_) {
+    HDC hdc_image = CreateCompatibleDC(NULL);
+    SelectBitmap(hdc_image, scaled_image_);
+    BLENDFUNCTION blend = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA};
+    AlphaBlend(hdc_, margin_.cx, margin_.cy, image_info.bmWidth,
+               image_info.bmHeight, hdc_image, 0, 0, image_info.bmWidth,
+               image_info.bmHeight, blend);
+    DeleteDC(hdc_image);
+  }
+
+  // caption
+  {
+    RECT rc = {text_offset_x, margin_.cy, close_button_rect_.left,
+               toast_size_.cy};
 
-    TEXTMETRIC tm_cap;
     SelectFont(hdc_, caption_font);
-    GetTextMetrics(hdc_, &tm_cap);
-
-    auto text_offset_x = margin_.cx;
-
-    BITMAP image_info = {};
-    if (scaled_image_) {
-        GetObject(scaled_image_, sizeof(image_info), &image_info);
-
-        text_offset_x += margin_.cx + image_info.bmWidth;
-    }
-
-    // calculate close button rect
-    POINT close_pos;
-    {
-        SIZE extent = {};
-        GetTextExtentPoint32W(hdc_, &close, 1, &extent);
-
-        close_button_rect_.right = toast_size_.cx;
-        close_button_rect_.top = 0;
-
-        close_pos.x = close_button_rect_.right - margin_.cy - extent.cx;
-        close_pos.y = close_button_rect_.top + margin_.cy;
-
-        close_button_rect_.left = close_pos.x - margin_.cy;
-        close_button_rect_.bottom = close_pos.y + extent.cy + margin_.cy;
-    }
-
-    // image
-    if (scaled_image_) {
-        HDC hdc_image = CreateCompatibleDC(NULL);
-        SelectBitmap(hdc_image, scaled_image_);
-        BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
-        AlphaBlend(hdc_, margin_.cx, margin_.cy,
-                   image_info.bmWidth, image_info.bmHeight,
-                   hdc_image, 0, 0,
-                   image_info.bmWidth, image_info.bmHeight,
-                   blend);
-        DeleteDC(hdc_image);
-    }
-
-    // caption
-    {
-        RECT rc = {
-            text_offset_x,
-            margin_.cy,
-            close_button_rect_.left,
-            toast_size_.cy
-        };
-
-        SelectFont(hdc_, caption_font);
-        SetTextColor(hdc_, fore_color);
-        DrawText(hdc_, data_->caption.data(), (UINT)data_->caption.length(),
-                 &rc, DT_SINGLELINE | DT_END_ELLIPSIS | DT_NOPREFIX);
-    }
-
-    // body text
-    if (!data_->body_text.empty()) {
-        RECT rc = {
-            text_offset_x,
-            2 * margin_.cy + tm_cap.tmAscent,
-            toast_size_.cx - margin_.cx,
-            toast_size_.cy - margin_.cy
-        };
-
-        SelectFont(hdc_, body_font);
-        SetTextColor(hdc_, dimmed_color);
-        DrawText(hdc_, data_->body_text.data(), (UINT)data_->body_text.length(),
-                 &rc,
-                 DT_LEFT | DT_WORDBREAK | DT_NOPREFIX |
-                 DT_END_ELLIPSIS | DT_EDITCONTROL);
-    }
-
-    // close button
-    {
-        SelectFont(hdc_, caption_font);
-        SetTextColor(hdc_, is_close_hot_ ? fore_color : dimmed_color);
-        ExtTextOut(hdc_, close_pos.x, close_pos.y, 0, nullptr,
-                   &close, 1, nullptr);
-    }
+    SetTextColor(hdc_, fore_color);
+    DrawText(hdc_, data_->caption.data(), (UINT)data_->caption.length(), &rc,
+             DT_SINGLELINE | DT_END_ELLIPSIS | DT_NOPREFIX);
+  }
+
+  // body text
+  if (!data_->body_text.empty()) {
+    RECT rc = {text_offset_x, 2 * margin_.cy + tm_cap.tmAscent,
+               toast_size_.cx - margin_.cx, toast_size_.cy - margin_.cy};
+
+    SelectFont(hdc_, body_font);
+    SetTextColor(hdc_, dimmed_color);
+    DrawText(hdc_, data_->body_text.data(), (UINT)data_->body_text.length(),
+             &rc,
+             DT_LEFT | DT_WORDBREAK | DT_NOPREFIX | DT_END_ELLIPSIS |
+                 DT_EDITCONTROL);
+  }
+
+  // close button
+  {
+    SelectFont(hdc_, caption_font);
+    SetTextColor(hdc_, is_close_hot_ ? fore_color : dimmed_color);
+    ExtTextOut(hdc_, close_pos.x, close_pos.y, 0, nullptr, &close, 1, nullptr);
+  }
 
-    is_content_updated_ = true;
+  is_content_updated_ = true;
 }
 
 void DesktopNotificationController::Toast::Invalidate() {
-    is_content_updated_ = false;
+  is_content_updated_ = false;
 }
 
 bool DesktopNotificationController::Toast::IsRedrawNeeded() const {
-    return !is_content_updated_;
+  return !is_content_updated_;
 }
 
 void DesktopNotificationController::Toast::UpdateBufferSize() {
-    if (hdc_) {
-        SIZE new_size;
-        {
-            TEXTMETRIC tm_cap = {};
-            HFONT font = data_->controller->GetCaptionFont();
-            if (font) {
-                SelectFont(hdc_, font);
-                if (!GetTextMetrics(hdc_, &tm_cap)) return;
+  if (hdc_) {
+    SIZE new_size;
+    {
+      TEXTMETRIC tm_cap = {};
+      HFONT font = data_->controller->GetCaptionFont();
+      if (font) {
+        SelectFont(hdc_, font);
+        if (!GetTextMetrics(hdc_, &tm_cap))
+          return;
+      }
+
+      TEXTMETRIC tm_body = {};
+      font = data_->controller->GetBodyFont();
+      if (font) {
+        SelectFont(hdc_, font);
+        if (!GetTextMetrics(hdc_, &tm_body))
+          return;
+      }
+
+      this->margin_ = {tm_cap.tmAveCharWidth * 2, tm_cap.tmAscent / 2};
+
+      new_size.cx = margin_.cx + (32 * tm_cap.tmAveCharWidth) + margin_.cx;
+      new_size.cy = margin_.cy + (tm_cap.tmHeight) + margin_.cy;
+
+      if (!data_->body_text.empty())
+        new_size.cy += margin_.cy + (3 * tm_body.tmHeight);
+
+      if (data_->image) {
+        BITMAP bm;
+        if (GetObject(data_->image, sizeof(bm), &bm)) {
+          // cap the image size
+          const int max_dim_size = 80;
+
+          auto width = bm.bmWidth;
+          auto height = bm.bmHeight;
+          if (width < height) {
+            if (height > max_dim_size) {
+              width = width * max_dim_size / height;
+              height = max_dim_size;
             }
-
-            TEXTMETRIC tm_body = {};
-            font = data_->controller->GetBodyFont();
-            if (font) {
-                SelectFont(hdc_, font);
-                if (!GetTextMetrics(hdc_, &tm_body)) return;
+          } else {
+            if (width > max_dim_size) {
+              height = height * max_dim_size / width;
+              width = max_dim_size;
             }
+          }
 
-            this->margin_ = { tm_cap.tmAveCharWidth * 2, tm_cap.tmAscent / 2 };
-
-            new_size.cx =
-                margin_.cx + (32 * tm_cap.tmAveCharWidth) + margin_.cx;
-            new_size.cy =
-                margin_.cy + (tm_cap.tmHeight) + margin_.cy;
-
-            if (!data_->body_text.empty())
-                new_size.cy += margin_.cy + (3 * tm_body.tmHeight);
-
-            if (data_->image) {
-                BITMAP bm;
-                if (GetObject(data_->image, sizeof(bm), &bm)) {
-                    // cap the image size
-                    const int max_dim_size = 80;
-
-                    auto width = bm.bmWidth;
-                    auto height = bm.bmHeight;
-                    if (width < height) {
-                        if (height > max_dim_size) {
-                            width = width * max_dim_size / height;
-                            height = max_dim_size;
-                        }
-                    } else {
-                        if (width > max_dim_size) {
-                            height = height * max_dim_size / width;
-                            width = max_dim_size;
-                        }
-                    }
-
-                    ScreenMetrics scr;
-                    SIZE image_draw_size = { scr.X(width), scr.Y(height) };
-
-                    new_size.cx += image_draw_size.cx + margin_.cx;
-
-                    auto height_with_image =
-                        margin_.cy + (image_draw_size.cy) + margin_.cy;
-
-                    if (new_size.cy < height_with_image)
-                        new_size.cy = height_with_image;
-
-                    UpdateScaledImage(image_draw_size);
-                }
-            }
+          ScreenMetrics scr;
+          SIZE image_draw_size = {scr.X(width), scr.Y(height)};
+
+          new_size.cx += image_draw_size.cx + margin_.cx;
+
+          auto height_with_image =
+              margin_.cy + (image_draw_size.cy) + margin_.cy;
+
+          if (new_size.cy < height_with_image)
+            new_size.cy = height_with_image;
+
+          UpdateScaledImage(image_draw_size);
         }
+      }
+    }
 
-        if (new_size.cx != this->toast_size_.cx ||
-            new_size.cy != this->toast_size_.cy) {
-            HDC hdc_screen = GetDC(NULL);
-            auto new_bitmap = CreateCompatibleBitmap(hdc_screen,
-                                                     new_size.cx, new_size.cy);
-            ReleaseDC(NULL, hdc_screen);
-
-            if (new_bitmap) {
-                if (SelectBitmap(hdc_, new_bitmap)) {
-                    RECT dirty1 = {}, dirty2 = {};
-                    if (toast_size_.cx < new_size.cx) {
-                        dirty1 = { toast_size_.cx, 0,
-                                   new_size.cx, toast_size_.cy };
-                    }
-                    if (toast_size_.cy < new_size.cy) {
-                        dirty2 = { 0, toast_size_.cy,
-                                   new_size.cx, new_size.cy };
-                    }
-
-                    if (this->bitmap_) DeleteBitmap(this->bitmap_);
-                    this->bitmap_ = new_bitmap;
-                    this->toast_size_ = new_size;
-
-                    Invalidate();
-
-                    // Resize also the DWM buffer to prevent flicker during
-                    // window resizing. Make sure any existing data is not
-                    // overwritten by marking the dirty region.
-                    {
-                        POINT origin = { 0, 0 };
-
-                        UPDATELAYEREDWINDOWINFO ulw;
-                        ulw.cbSize = sizeof(ulw);
-                        ulw.hdcDst = NULL;
-                        ulw.pptDst = nullptr;
-                        ulw.psize = &toast_size_;
-                        ulw.hdcSrc = hdc_;
-                        ulw.pptSrc = &origin;
-                        ulw.crKey = 0;
-                        ulw.pblend = nullptr;
-                        ulw.dwFlags = 0;
-                        ulw.prcDirty = &dirty1;
-                        auto b1 = UpdateLayeredWindowIndirect(hwnd_, &ulw);
-                        ulw.prcDirty = &dirty2;
-                        auto b2 = UpdateLayeredWindowIndirect(hwnd_, &ulw);
-                        _ASSERT(b1 && b2);
-                    }
-
-                    return;
-                }
-
-                DeleteBitmap(new_bitmap);
-            }
+    if (new_size.cx != this->toast_size_.cx ||
+        new_size.cy != this->toast_size_.cy) {
+      HDC hdc_screen = GetDC(NULL);
+      auto new_bitmap =
+          CreateCompatibleBitmap(hdc_screen, new_size.cx, new_size.cy);
+      ReleaseDC(NULL, hdc_screen);
+
+      if (new_bitmap) {
+        if (SelectBitmap(hdc_, new_bitmap)) {
+          RECT dirty1 = {}, dirty2 = {};
+          if (toast_size_.cx < new_size.cx) {
+            dirty1 = {toast_size_.cx, 0, new_size.cx, toast_size_.cy};
+          }
+          if (toast_size_.cy < new_size.cy) {
+            dirty2 = {0, toast_size_.cy, new_size.cx, new_size.cy};
+          }
+
+          if (this->bitmap_)
+            DeleteBitmap(this->bitmap_);
+          this->bitmap_ = new_bitmap;
+          this->toast_size_ = new_size;
+
+          Invalidate();
+
+          // Resize also the DWM buffer to prevent flicker during
+          // window resizing. Make sure any existing data is not
+          // overwritten by marking the dirty region.
+          {
+            POINT origin = {0, 0};
+
+            UPDATELAYEREDWINDOWINFO ulw;
+            ulw.cbSize = sizeof(ulw);
+            ulw.hdcDst = NULL;
+            ulw.pptDst = nullptr;
+            ulw.psize = &toast_size_;
+            ulw.hdcSrc = hdc_;
+            ulw.pptSrc = &origin;
+            ulw.crKey = 0;
+            ulw.pblend = nullptr;
+            ulw.dwFlags = 0;
+            ulw.prcDirty = &dirty1;
+            auto b1 = UpdateLayeredWindowIndirect(hwnd_, &ulw);
+            ulw.prcDirty = &dirty2;
+            auto b2 = UpdateLayeredWindowIndirect(hwnd_, &ulw);
+            _ASSERT(b1 && b2);
+          }
+
+          return;
         }
+
+        DeleteBitmap(new_bitmap);
+      }
     }
+  }
 }
 
 void DesktopNotificationController::Toast::UpdateScaledImage(const SIZE& size) {
-    BITMAP bm;
-    if (!GetObject(scaled_image_, sizeof(bm), &bm) ||
-        bm.bmWidth != size.cx ||
-        bm.bmHeight != size.cy) {
-        if (scaled_image_) DeleteBitmap(scaled_image_);
-        scaled_image_ = StretchBitmap(data_->image, size.cx, size.cy);
-    }
+  BITMAP bm;
+  if (!GetObject(scaled_image_, sizeof(bm), &bm) || bm.bmWidth != size.cx ||
+      bm.bmHeight != size.cy) {
+    if (scaled_image_)
+      DeleteBitmap(scaled_image_);
+    scaled_image_ = StretchBitmap(data_->image, size.cx, size.cy);
+  }
 }
 
 void DesktopNotificationController::Toast::UpdateContents() {
-    Draw();
-
-    if (IsWindowVisible(hwnd_)) {
-        RECT rc;
-        GetWindowRect(hwnd_, &rc);
-        POINT origin = { 0, 0 };
-        SIZE size = { rc.right - rc.left, rc.bottom - rc.top };
-        UpdateLayeredWindow(hwnd_, NULL, nullptr, &size,
-                            hdc_, &origin, 0, nullptr, 0);
-    }
+  Draw();
+
+  if (IsWindowVisible(hwnd_)) {
+    RECT rc;
+    GetWindowRect(hwnd_, &rc);
+    POINT origin = {0, 0};
+    SIZE size = {rc.right - rc.left, rc.bottom - rc.top};
+    UpdateLayeredWindow(hwnd_, NULL, nullptr, &size, hdc_, &origin, 0, nullptr,
+                        0);
+  }
 }
 
 void DesktopNotificationController::Toast::Dismiss() {
-    if (!is_non_interactive_) {
-        // Set a flag to prevent further interaction. We don't disable the HWND
-        // because we still want to receive mouse move messages in order to keep
-        // the toast under the cursor and not collapse it while dismissing.
-        is_non_interactive_ = true;
-
-        AutoDismiss();
-    }
+  if (!is_non_interactive_) {
+    // Set a flag to prevent further interaction. We don't disable the HWND
+    // because we still want to receive mouse move messages in order to keep
+    // the toast under the cursor and not collapse it while dismissing.
+    is_non_interactive_ = true;
+
+    AutoDismiss();
+  }
 }
 
 void DesktopNotificationController::Toast::AutoDismiss() {
-    KillTimer(hwnd_, TimerID_AutoDismiss);
-    StartEaseOut();
+  KillTimer(hwnd_, TimerID_AutoDismiss);
+  StartEaseOut();
 }
 
 void DesktopNotificationController::Toast::CancelDismiss() {
-    KillTimer(hwnd_, TimerID_AutoDismiss);
-    ease_out_active_ = false;
-    ease_out_pos_ = 0;
+  KillTimer(hwnd_, TimerID_AutoDismiss);
+  ease_out_active_ = false;
+  ease_out_pos_ = 0;
 }
 
 void DesktopNotificationController::Toast::ScheduleDismissal() {
-    ULONG duration;
-    if (!SystemParametersInfo(SPI_GETMESSAGEDURATION, 0, &duration, 0)) {
-        duration = 5;
-    }
-    SetTimer(hwnd_, TimerID_AutoDismiss, duration * 1000, nullptr);
+  ULONG duration;
+  if (!SystemParametersInfo(SPI_GETMESSAGEDURATION, 0, &duration, 0)) {
+    duration = 5;
+  }
+  SetTimer(hwnd_, TimerID_AutoDismiss, duration * 1000, nullptr);
 }
 
 void DesktopNotificationController::Toast::ResetContents() {
-    if (scaled_image_) {
-        DeleteBitmap(scaled_image_);
-        scaled_image_ = NULL;
-    }
+  if (scaled_image_) {
+    DeleteBitmap(scaled_image_);
+    scaled_image_ = NULL;
+  }
 
-    Invalidate();
+  Invalidate();
 }
 
 void DesktopNotificationController::Toast::PopUp(int y) {
-    vertical_pos_target_ = vertical_pos_ = y;
-    StartEaseIn();
+  vertical_pos_target_ = vertical_pos_ = y;
+  StartEaseIn();
 }
 
 void DesktopNotificationController::Toast::SetVerticalPosition(int y) {
-    // Don't restart animation if current target is the same
-    if (y == vertical_pos_target_)
-        return;
-
-    // Make sure the new animation's origin is at the current position
-    vertical_pos_ += static_cast<int>(
-        (vertical_pos_target_ - vertical_pos_) * stack_collapse_pos_);
-
-    // Set new target position and start the animation
-    vertical_pos_target_ = y;
-    stack_collapse_start_ = GetTickCount();
-    data_->controller->StartAnimation();
+  // Don't restart animation if current target is the same
+  if (y == vertical_pos_target_)
+    return;
+
+  // Make sure the new animation's origin is at the current position
+  vertical_pos_ += static_cast<int>((vertical_pos_target_ - vertical_pos_) *
+                                    stack_collapse_pos_);
+
+  // Set new target position and start the animation
+  vertical_pos_target_ = y;
+  stack_collapse_start_ = GetTickCount();
+  data_->controller->StartAnimation();
 }
 
-HDWP DesktopNotificationController::Toast::Animate(
-    HDWP hdwp, const POINT& origin) {
-    UpdateBufferSize();
+HDWP DesktopNotificationController::Toast::Animate(HDWP hdwp,
+                                                   const POINT& origin) {
+  UpdateBufferSize();
 
-    if (IsRedrawNeeded())
-        Draw();
+  if (IsRedrawNeeded())
+    Draw();
 
-    POINT src_origin = { 0, 0 };
+  POINT src_origin = {0, 0};
 
-    UPDATELAYEREDWINDOWINFO ulw;
-    ulw.cbSize = sizeof(ulw);
-    ulw.hdcDst = NULL;
-    ulw.pptDst = nullptr;
-    ulw.psize = nullptr;
-    ulw.hdcSrc = hdc_;
-    ulw.pptSrc = &src_origin;
-    ulw.crKey = 0;
-    ulw.pblend = nullptr;
-    ulw.dwFlags = 0;
-    ulw.prcDirty = nullptr;
+  UPDATELAYEREDWINDOWINFO ulw;
+  ulw.cbSize = sizeof(ulw);
+  ulw.hdcDst = NULL;
+  ulw.pptDst = nullptr;
+  ulw.psize = nullptr;
+  ulw.hdcSrc = hdc_;
+  ulw.pptSrc = &src_origin;
+  ulw.crKey = 0;
+  ulw.pblend = nullptr;
+  ulw.dwFlags = 0;
+  ulw.prcDirty = nullptr;
 
-    POINT pt = { 0, 0 };
-    SIZE size = { 0, 0 };
-    BLENDFUNCTION blend;
-    UINT dwpFlags = SWP_NOACTIVATE | SWP_SHOWWINDOW |
-                    SWP_NOREDRAW | SWP_NOCOPYBITS;
+  POINT pt = {0, 0};
+  SIZE size = {0, 0};
+  BLENDFUNCTION blend;
+  UINT dwpFlags =
+      SWP_NOACTIVATE | SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOCOPYBITS;
 
-    auto ease_in_pos = AnimateEaseIn();
-    auto ease_out_pos = AnimateEaseOut();
-    auto stack_collapse_pos = AnimateStackCollapse();
+  auto ease_in_pos = AnimateEaseIn();
+  auto ease_out_pos = AnimateEaseOut();
+  auto stack_collapse_pos = AnimateStackCollapse();
 
-    auto y_offset = (vertical_pos_target_ - vertical_pos_) * stack_collapse_pos;
+  auto y_offset = (vertical_pos_target_ - vertical_pos_) * stack_collapse_pos;
 
-    size.cx = static_cast<int>(toast_size_.cx * ease_in_pos);
-    size.cy = toast_size_.cy;
+  size.cx = static_cast<int>(toast_size_.cx * ease_in_pos);
+  size.cy = toast_size_.cy;
 
-    pt.x = origin.x - size.cx;
-    pt.y = static_cast<int>(origin.y - vertical_pos_ - y_offset - size.cy);
+  pt.x = origin.x - size.cx;
+  pt.y = static_cast<int>(origin.y - vertical_pos_ - y_offset - size.cy);
 
-    ulw.pptDst = &pt;
-    ulw.psize = &size;
+  ulw.pptDst = &pt;
+  ulw.psize = &size;
 
-    if (ease_in_active_ && ease_in_pos == 1.0f) {
-        ease_in_active_ = false;
-        ScheduleDismissal();
-    }
+  if (ease_in_active_ && ease_in_pos == 1.0f) {
+    ease_in_active_ = false;
+    ScheduleDismissal();
+  }
 
-    this->ease_in_pos_ = ease_in_pos;
-    this->stack_collapse_pos_ = stack_collapse_pos;
+  this->ease_in_pos_ = ease_in_pos;
+  this->stack_collapse_pos_ = stack_collapse_pos;
 
-    if (ease_out_pos != this->ease_out_pos_) {
-        blend.BlendOp = AC_SRC_OVER;
-        blend.BlendFlags = 0;
-        blend.SourceConstantAlpha = (BYTE)(255 * (1.0f - ease_out_pos));
-        blend.AlphaFormat = 0;
+  if (ease_out_pos != this->ease_out_pos_) {
+    blend.BlendOp = AC_SRC_OVER;
+    blend.BlendFlags = 0;
+    blend.SourceConstantAlpha = (BYTE)(255 * (1.0f - ease_out_pos));
+    blend.AlphaFormat = 0;
 
-        ulw.pblend = &blend;
-        ulw.dwFlags = ULW_ALPHA;
+    ulw.pblend = &blend;
+    ulw.dwFlags = ULW_ALPHA;
 
-        this->ease_out_pos_ = ease_out_pos;
+    this->ease_out_pos_ = ease_out_pos;
 
-        if (ease_out_pos == 1.0f) {
-            ease_out_active_ = false;
+    if (ease_out_pos == 1.0f) {
+      ease_out_active_ = false;
 
-            dwpFlags &= ~SWP_SHOWWINDOW;
-            dwpFlags |= SWP_HIDEWINDOW;
-        }
+      dwpFlags &= ~SWP_SHOWWINDOW;
+      dwpFlags |= SWP_HIDEWINDOW;
     }
+  }
 
-    if (stack_collapse_pos == 1.0f) {
-        vertical_pos_ = vertical_pos_target_;
-    }
+  if (stack_collapse_pos == 1.0f) {
+    vertical_pos_ = vertical_pos_target_;
+  }
 
-    // `UpdateLayeredWindowIndirect` updates position, size, and transparency.
-    // `DeferWindowPos` updates z-order, and also position and size in case
-    // ULWI fails, which can happen when one of the dimensions is zero (e.g.
-    // at the beginning of ease-in).
+  // `UpdateLayeredWindowIndirect` updates position, size, and transparency.
+  // `DeferWindowPos` updates z-order, and also position and size in case
+  // ULWI fails, which can happen when one of the dimensions is zero (e.g.
+  // at the beginning of ease-in).
 
-    auto ulw_result = UpdateLayeredWindowIndirect(hwnd_, &ulw);
-    hdwp = DeferWindowPos(hdwp, hwnd_, HWND_TOPMOST,
-                          pt.x, pt.y, size.cx, size.cy, dwpFlags);
-    return hdwp;
+  auto ulw_result = UpdateLayeredWindowIndirect(hwnd_, &ulw);
+  hdwp = DeferWindowPos(hdwp, hwnd_, HWND_TOPMOST, pt.x, pt.y, size.cx, size.cy,
+                        dwpFlags);
+  return hdwp;
 }
 
 void DesktopNotificationController::Toast::StartEaseIn() {
-    _ASSERT(!ease_in_active_);
-    ease_in_start_ = GetTickCount();
-    ease_in_active_ = true;
-    data_->controller->StartAnimation();
+  _ASSERT(!ease_in_active_);
+  ease_in_start_ = GetTickCount();
+  ease_in_active_ = true;
+  data_->controller->StartAnimation();
 }
 
 void DesktopNotificationController::Toast::StartEaseOut() {
-    _ASSERT(!ease_out_active_);
-    ease_out_start_ = GetTickCount();
-    ease_out_active_ = true;
-    data_->controller->StartAnimation();
+  _ASSERT(!ease_out_active_);
+  ease_out_start_ = GetTickCount();
+  ease_out_active_ = true;
+  data_->controller->StartAnimation();
 }
 
 bool DesktopNotificationController::Toast::IsStackCollapseActive() const {
-    return (vertical_pos_ != vertical_pos_target_);
+  return (vertical_pos_ != vertical_pos_target_);
 }
 
 float DesktopNotificationController::Toast::AnimateEaseIn() {
-    if (!ease_in_active_)
-        return ease_in_pos_;
+  if (!ease_in_active_)
+    return ease_in_pos_;
 
-    constexpr DWORD duration = 500;
-    auto elapsed = GetTickCount() - ease_in_start_;
-    float time = std::min(duration, elapsed) / static_cast<float>(duration);
+  constexpr DWORD duration = 500;
+  auto elapsed = GetTickCount() - ease_in_start_;
+  float time = std::min(duration, elapsed) / static_cast<float>(duration);
 
-    // decelerating exponential ease
-    const float a = -8.0f;
-    auto pos = (std::exp(a * time) - 1.0f) / (std::exp(a) - 1.0f);
+  // decelerating exponential ease
+  const float a = -8.0f;
+  auto pos = (std::exp(a * time) - 1.0f) / (std::exp(a) - 1.0f);
 
-    return pos;
+  return pos;
 }
 
 float DesktopNotificationController::Toast::AnimateEaseOut() {
-    if (!ease_out_active_)
-        return ease_out_pos_;
+  if (!ease_out_active_)
+    return ease_out_pos_;
 
-    constexpr DWORD duration = 120;
-    auto elapsed = GetTickCount() - ease_out_start_;
-    float time = std::min(duration, elapsed) / static_cast<float>(duration);
+  constexpr DWORD duration = 120;
+  auto elapsed = GetTickCount() - ease_out_start_;
+  float time = std::min(duration, elapsed) / static_cast<float>(duration);
 
-    // accelerating circle ease
-    auto pos = 1.0f - std::sqrt(1 - time * time);
+  // accelerating circle ease
+  auto pos = 1.0f - std::sqrt(1 - time * time);
 
-    return pos;
+  return pos;
 }
 
 float DesktopNotificationController::Toast::AnimateStackCollapse() {
-    if (!IsStackCollapseActive())
-        return stack_collapse_pos_;
+  if (!IsStackCollapseActive())
+    return stack_collapse_pos_;
 
-    constexpr DWORD duration = 500;
-    auto elapsed = GetTickCount() - stack_collapse_start_;
-    float time = std::min(duration, elapsed) / static_cast<float>(duration);
+  constexpr DWORD duration = 500;
+  auto elapsed = GetTickCount() - stack_collapse_start_;
+  float time = std::min(duration, elapsed) / static_cast<float>(duration);
 
-    // decelerating exponential ease
-    const float a = -8.0f;
-    auto pos = (std::exp(a * time) - 1.0f) / (std::exp(a) - 1.0f);
+  // decelerating exponential ease
+  const float a = -8.0f;
+  auto pos = (std::exp(a * time) - 1.0f) / (std::exp(a) - 1.0f);
 
-    return pos;
+  return pos;
 }
 
-}   // namespace brightray
+}  // namespace brightray

brightray/browser/win/win32_desktop_notifications/toast.h

@@ -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 LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
-                                    WPARAM wparam, LPARAM lparam);
-
-    const std::shared_ptr<NotificationData>& GetNotification() const {
-        return data_;
-    }
-
-    void ResetContents();
-
-    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_;
-    }
+  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);
+
+  const std::shared_ptr<NotificationData>& GetNotification() const {
+    return data_;
+  }
+
+  void ResetContents();
+
+  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_;
+  }
 
  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");
-
-    const HWND hwnd_;
-    HDC hdc_;
-    HBITMAP bitmap_ = NULL;
-
-    const std::shared_ptr<NotificationData> data_;  // never 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;
+  static constexpr const TCHAR class_name_[] = TEXT("DesktopNotificationToast");
+
+  const HWND hwnd_;
+  HDC hdc_;
+  HBITMAP bitmap_ = NULL;
+
+  const std::shared_ptr<NotificationData> data_;  // never 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;
 };
 
-}   // namespace brightray
+}  // namespace brightray

brightray/browser/win/win32_notification.cc

@@ -11,50 +11,50 @@
 namespace brightray {
 
 void Win32Notification::Show(const NotificationOptions& options) {
-    auto presenter = static_cast<NotificationPresenterWin7*>(this->presenter());
-    if (!presenter) return;
-
-    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;
-
-            HDC hdcScreen = GetDC(NULL);
-            image = CreateDIBitmap(hdcScreen, &bmi, CBM_INIT,
-                                   options.icon.getPixels(),
-                                   reinterpret_cast<BITMAPINFO*>(&bmi),
-                                   DIB_RGB_COLORS);
-            ReleaseDC(NULL, hdcScreen);
-        }
+  auto presenter = static_cast<NotificationPresenterWin7*>(this->presenter());
+  if (!presenter)
+    return;
+
+  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;
+
+      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);
-
-    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);
-    }
+  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);
+  }
 
-    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

brightray/browser/win/win32_notification.h

@@ -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

brightray/browser/win/windows_toast_notification.cc

@@ -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;
 }

brightray/common/application_info_win.cc

@@ -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);

brightray/common/content_client.cc

@@ -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);
 }

brightray/common/main_delegate.cc

@@ -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);