Merge pull request #167 from atom/code-cleanup

Cleanup of the notification code

brightray/brightray.gyp

@@ -164,8 +164,11 @@
           'msvs_settings': {
             'VCLinkerTool': {
               'AdditionalDependencies': [
+                # Windows Runtime.
+                'crypt32.lib',
                 'runtimeobject.lib',
-                'windowsapp.lib'
+                'shlwapi.lib',
+                'windowsapp.lib',
               ],
             },
           },
@@ -203,8 +206,6 @@
                 'msvs_settings': {
                   'VCLinkerTool': {
                     'AdditionalDependencies': [
-                      'Shlwapi.lib',
-                      'Crypt32.lib',
                       'advapi32.lib',
                       'dbghelp.lib',
                       'delayimp.lib',

brightray/browser/platform_notification_service_impl.cc

@@ -24,13 +24,13 @@ PlatformNotificationServiceImpl::PlatformNotificationServiceImpl() {}
 PlatformNotificationServiceImpl::~PlatformNotificationServiceImpl() {}
 
 NotificationPresenter* PlatformNotificationServiceImpl::notification_presenter() {
-  if (!notification_presenter_) {
   #if defined(OS_WIN)
   // Bail out if on Windows 7 or even lower, no operating will follow
-    if (base::win::GetVersion() < base::win::VERSION_WIN8) {
+  if (base::win::GetVersion() < base::win::VERSION_WIN8)
-      return notification_presenter_.get();
+    return nullptr;
-    }
   #endif
+
+  if (!notification_presenter_) {
     // Create a new presenter if on OS X, Linux, or Windows 8+
     notification_presenter_.reset(NotificationPresenter::Create());
   }

brightray/browser/win/notification_presenter_win.cc

@@ -4,16 +4,16 @@
 // found in the LICENSE-CHROMIUM file.
 
 #include "browser/win/notification_presenter_win.h"
+
 #include "base/win/windows_version.h"
+#include "browser/win/windows_toast_notification.h"
+#include "common/application_info.h"
 #include "content/public/browser/desktop_notification_delegate.h"
 #include "content/public/common/platform_notification_data.h"
 #include "third_party/skia/include/core/SkBitmap.h"
-#include "common/application_info.h"
 
 #pragma comment(lib, "runtimeobject.lib")
-#pragma comment(lib, "Crypt32.lib")
 
-using namespace WinToasts;
 using namespace Microsoft::WRL;
 using namespace ABI::Windows::UI::Notifications;
 using namespace ABI::Windows::Data::Xml::Dom;
@@ -21,13 +21,21 @@ using namespace ABI::Windows::Foundation;
 
 namespace brightray {
 
+namespace {
+
+void RemoveNotification(base::WeakPtr<WindowsToastNotification> notification) {
+  if (notification)
+    notification->DismissNotification();
+}
+
+}  // namespace
+
 // static
 NotificationPresenter* NotificationPresenter::Create() {
   return new NotificationPresenterWin;
 }
 
 NotificationPresenterWin::NotificationPresenterWin() {
-  m_lastNotification = nullptr;
 }
 
 NotificationPresenterWin::~NotificationPresenterWin() {
@@ -36,31 +44,16 @@ NotificationPresenterWin::~NotificationPresenterWin() {
 void NotificationPresenterWin::ShowNotification(
     const content::PlatformNotificationData& data,
     const SkBitmap& icon,
-  scoped_ptr<content::DesktopNotificationDelegate> delegate_ptr,
+    scoped_ptr<content::DesktopNotificationDelegate> delegate,
     base::Closure* cancel_callback) {
-  
+  // This class manages itself.
-  std::wstring title = data.title;
+  auto notification = new WindowsToastNotification(
-  std::wstring body = data.body;
+      GetApplicationName(), delegate.Pass());
-  std::string iconPath = data.icon.spec();  
+  notification->ShowNotification(data.title, data.body, data.icon.spec());
-  std::string appName = GetApplicationName();
-
-  // toast notification supported in version >= Windows 8
-  // for prior versions, use Tray.displayBalloon
-  if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
-    wtn = new WindowsToastNotification(appName.c_str(), delegate_ptr.release());
-    wtn->ShowNotification(title.c_str(), body.c_str(), iconPath, m_lastNotification);
-  }
 
   if (cancel_callback) {
     *cancel_callback = base::Bind(
-      &NotificationPresenterWin::RemoveNotification,
+        &RemoveNotification, notification->GetWeakPtr());
-      base::Unretained(this));
-  }
-}
-
-void NotificationPresenterWin::RemoveNotification() {
-  if (m_lastNotification != nullptr && wtn != NULL) {
-    wtn->DismissNotification(m_lastNotification);
   }
 }
 

brightray/browser/win/notification_presenter_win.h

@@ -13,18 +13,10 @@
 // windowsNotification.onclick = function () { console.log("Notification clicked") };
 // windowsNotification.onclose = function () { console.log("Notification dismissed") };
 
+#ifndef BRIGHTRAY_BROWSER_WIN_NOTIFICATION_PRESENTER_WIN_H_
+#define BRIGHTRAY_BROWSER_WIN_NOTIFICATION_PRESENTER_WIN_H_
 
-#ifndef BRIGHTRAY_BROWSER_NOTIFICATION_PRESENTER_WIN_H_
-#define BRIGHTRAY_BROWSER_NOTIFICATION_PRESENTER_WIN_H_
-
-#include "base/compiler_specific.h"
 #include "browser/notification_presenter.h"
-#include "windows_toast_notification.h"
-
-#include <windows.h>
-#include <windows.ui.notifications.h>
-#include <wrl/client.h>
-#include <wrl/implements.h>
 
 namespace brightray {
 
@@ -39,13 +31,10 @@ class NotificationPresenterWin : public NotificationPresenter {
       scoped_ptr<content::DesktopNotificationDelegate> delegate,
       base::Closure* cancel_callback) override;
 
-  void RemoveNotification();
-
  private:
-  WinToasts::WindowsToastNotification* wtn;
+  DISALLOW_COPY_AND_ASSIGN(NotificationPresenterWin);
-  Microsoft::WRL::ComPtr<ABI::Windows::UI::Notifications::IToastNotification> m_lastNotification;
 };
 
 }  // namespace
 
-#endif // BRIGHTRAY_BROWSER_NOTIFICATION_PRESENTER_WIN_H_
+#endif  // BRIGHTRAY_BROWSER_WIN_NOTIFICATION_PRESENTER_WIN_H_

brightray/browser/win/scoped_hstring.cc

@@ -0,0 +1,33 @@
+// Copyright (c) 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE-CHROMIUM file.
+
+#include "browser/win/scoped_hstring.h"
+
+#include <winstring.h>
+
+ScopedHString::ScopedHString(const wchar_t* source)
+    : str_(nullptr) {
+  Set(source);
+}
+
+ScopedHString::ScopedHString(const std::wstring& source)
+    : str_(nullptr) {
+  WindowsCreateString(source.c_str(), source.length(), &str_);
+}
+
+ScopedHString::ScopedHString() : str_(nullptr) {
+}
+
+ScopedHString::~ScopedHString() {
+  if (str_)
+    WindowsDeleteString(str_);
+}
+
+void ScopedHString::Set(const wchar_t* source) {
+  if (str_) {
+    WindowsDeleteString(str_);
+    str_ = nullptr;
+  }
+  WindowsCreateString(source, wcslen(source), &str_);
+}

brightray/browser/win/scoped_hstring.h

@@ -0,0 +1,39 @@
+// Copyright (c) 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE-CHROMIUM file.
+
+#ifndef BRIGHTRAY_BROWSER_WIN_SCOPED_HSTRING_H_
+#define BRIGHTRAY_BROWSER_WIN_SCOPED_HSTRING_H_
+
+#include <string>
+
+#include <hstring.h>
+#include <windows.h>
+
+#include "base/basictypes.h"
+
+class ScopedHString {
+ public:
+  // Copy from |source|.
+  ScopedHString(const wchar_t* source);
+  ScopedHString(const std::wstring& source);
+  // Create empty string.
+  ScopedHString();
+  ~ScopedHString();
+
+  // Sets to |source|.
+  void Set(const wchar_t* source);
+
+  // Returns string.
+  operator HSTRING() const { return str_; }
+
+  // Whether there is a string created.
+  bool success() const { return str_; }
+
+ private:
+  HSTRING str_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedHString);
+};
+
+#endif  // BRIGHTRAY_BROWSER_WIN_SCOPED_HSTRING_H_

brightray/browser/win/windows_toast_notification.cc

@@ -3,364 +3,266 @@
 // Thanks to both of those folks mentioned above who first thought up a bunch of this code
 // and released it as MIT to the world.
 
-#include "windows_toast_notification.h"
+#include "browser/win/windows_toast_notification.h"
+
+#include "base/strings/utf_string_conversions.h"
+#include "browser/win/scoped_hstring.h"
 #include "content/public/browser/desktop_notification_delegate.h"
 
-using namespace WinToasts;
-using namespace Microsoft::WRL;
-using namespace ABI::Windows::UI::Notifications;
 using namespace ABI::Windows::Data::Xml::Dom;
 
-#define BREAK_IF_BAD(hr)    if(!SUCCEEDED(hr)) break;
+namespace brightray {
 
-namespace WinToasts {
+namespace {
 
 // Initialize Windows Runtime
-static HRESULT init = Windows::Foundation::Initialize(RO_INIT_MULTITHREADED);
+HRESULT init = Windows::Foundation::Initialize(RO_INIT_MULTITHREADED);
 
-WindowsToastNotification::WindowsToastNotification(const char* appName, content::DesktopNotificationDelegate* delegate)
+}  // namespace
-{
-    HSTRING toastNotifMgrStr = NULL;
-    HSTRING appId = NULL;
 
-    HRESULT hr = CreateHString(RuntimeClass_Windows_UI_Notifications_ToastNotificationManager, &toastNotifMgrStr);
+WindowsToastNotification::WindowsToastNotification(
+    const std::string& app_name,
+    scoped_ptr<content::DesktopNotificationDelegate> delegate)
+    : delegate_(delegate.Pass()),
+      weak_factory_(this) {
+  ScopedHString toast_manager_str(
+      RuntimeClass_Windows_UI_Notifications_ToastNotificationManager);
+  if (!toast_manager_str.success())
+    return;
+  HRESULT hr = Windows::Foundation::GetActivationFactory(
+      toast_manager_str, &toast_manager_);
+  if (FAILED(hr))
+    return;
 
-    hr = Windows::Foundation::GetActivationFactory(toastNotifMgrStr, &m_toastManager);
+  ScopedHString app_id(base::UTF8ToUTF16(app_name).c_str());
+  if (!app_id.success())
+    return;
 
-    WCHAR wAppName[MAX_PATH];
+  toast_manager_->CreateToastNotifierWithId(app_id, &toast_notifier_);
-    swprintf(wAppName, ARRAYSIZE(wAppName), L"%S", appName);
-    hr = CreateHString(wAppName, &appId);
-
-    m_toastManager->CreateToastNotifierWithId(appId, &m_toastNotifier);
-
-    if (toastNotifMgrStr != NULL) {
-        WindowsDeleteString(toastNotifMgrStr);
 }
 
-    if (appId != NULL) {
+WindowsToastNotification::~WindowsToastNotification() {
-        WindowsDeleteString(appId);
 }
 
-    n_delegate = delegate;
+void WindowsToastNotification::ShowNotification(
+    const std::wstring& title,
+    const std::wstring& msg,
+    std::string icon_path) {
+  ComPtr<IXmlDocument> toast_xml;
+  if(FAILED(GetToastXml(toast_manager_.Get(), title, msg, icon_path, &toast_xml)))
+    return;
+
+  ScopedHString toast_str(
+      RuntimeClass_Windows_UI_Notifications_ToastNotification);
+  if (!toast_str.success())
+    return;
+
+  ComPtr<IToastNotificationFactory> toast_factory;
+  if (FAILED(Windows::Foundation::GetActivationFactory(toast_str,
+                                                       &toast_factory)))
+    return;
+
+  if (FAILED(toast_factory->CreateToastNotification(toast_xml.Get(),
+                                                    &toast_notification_)))
+    return;
+
+  if (FAILED(SetupCallbacks(toast_notification_.Get())))
+    return;
+
+  if (FAILED(toast_notifier_->Show(toast_notification_.Get())))
+    return;
+
+  delegate_->NotificationDisplayed();
 }
 
-WindowsToastNotification::~WindowsToastNotification()
+void WindowsToastNotification::DismissNotification() {
-{
+  toast_notifier_->Hide(toast_notification_.Get());
-    if (n_delegate) {
-        delete n_delegate;
-    }
 }
 
-void WindowsToastNotification::ShowNotification(const WCHAR* title, const WCHAR* msg, std::string iconPath, ComPtr<IToastNotification>& toast)
+void WindowsToastNotification::NotificationClicked() {
-{        
+  delegate_->NotificationClick();
-    HRESULT hr;
-    HSTRING toastNotifStr = NULL;
-
-    do {         
-        ComPtr<IXmlDocument> toastXml;
-        hr = GetToastXml(m_toastManager.Get(), title, msg, iconPath, &toastXml);
-        BREAK_IF_BAD(hr);
-
-        hr = CreateHString(RuntimeClass_Windows_UI_Notifications_ToastNotification, &toastNotifStr);
-        BREAK_IF_BAD(hr);
-
-        ComPtr<IToastNotificationFactory> toastFactory;
-        hr = Windows::Foundation::GetActivationFactory(toastNotifStr, &toastFactory);
-        BREAK_IF_BAD(hr);
-
-        hr = toastFactory->CreateToastNotification(toastXml.Get(), &toast);
-        BREAK_IF_BAD(hr);
-
-        hr = SetupCallbacks(toast.Get());
-        BREAK_IF_BAD(hr);
-
-        hr = m_toastNotifier->Show(toast.Get());
-        BREAK_IF_BAD(hr);
-
-        n_delegate->NotificationDisplayed();
-    } while (FALSE);
-
-    if (toastNotifStr != NULL) {
-        WindowsDeleteString(toastNotifStr);
-    }
-}
-
-void WindowsToastNotification::DismissNotification(ComPtr<IToastNotification> toast)
-{
-    m_toastNotifier->Hide(toast.Get());
-}
-
-void WindowsToastNotification::NotificationClicked()
-{
   delete this;
 }
 
-void WindowsToastNotification::NotificationDismissed()
+void WindowsToastNotification::NotificationDismissed() {
-{
+  delegate_->NotificationClosed();
   delete this;
 }
 
-HRESULT WindowsToastNotification::GetToastXml(
+bool WindowsToastNotification::GetToastXml(
     IToastNotificationManagerStatics* toastManager,
-    const WCHAR* title,
+    const std::wstring& title,
-    const WCHAR* msg,
+    const std::wstring& msg,
-    std::string iconPath,
+    std::string icon_path,
-    IXmlDocument** toastXml) {
+    IXmlDocument** toast_xml) {
- 
+  ToastTemplateType template_type;
-    HRESULT hr;
+  if (title.empty() || msg.empty()) {
-    ToastTemplateType templateType;
+    // Single line toast.
-    if (title == NULL || msg == NULL) {
+    template_type = icon_path.empty() ? ToastTemplateType_ToastText01 :
-        // Single line toast
+                                        ToastTemplateType_ToastImageAndText01;
-        templateType = iconPath.length() == 0 ? ToastTemplateType_ToastText01 : ToastTemplateType_ToastImageAndText01;
+    if (FAILED(toast_manager_->GetTemplateContent(template_type, toast_xml)))
-        hr = m_toastManager->GetTemplateContent(templateType, toastXml);
+      return false;
-        if (SUCCEEDED(hr)) {
+    if (!SetXmlText(*toast_xml, title.empty() ? msg : title))
-            const WCHAR* text = title != NULL ? title : msg;
+      return false;
-            hr = SetXmlText(*toastXml, text);
-        }
   } else {
-        // Title and body toast
+    // Title and body toast.
-        templateType = iconPath.length() == 0 ? ToastTemplateType_ToastText02 : ToastTemplateType_ToastImageAndText02;
+    template_type = icon_path.empty() ? ToastTemplateType_ToastText02 :
-        hr = toastManager->GetTemplateContent(templateType, toastXml);
+                                        ToastTemplateType_ToastImageAndText02;
-        if (SUCCEEDED(hr)) {
+    if (FAILED(toastManager->GetTemplateContent(template_type, toast_xml)))
-            hr = SetXmlText(*toastXml, title, msg);
+      return false;
-        }
+    if (!SetXmlText(*toast_xml, title, msg))
+      return false;
   }
 
-    if (iconPath.length() != 0 && SUCCEEDED(hr)) {
   // Toast has image
-        if (SUCCEEDED(hr)) {
+  if (!icon_path.empty())
-            hr = SetXmlImage(*toastXml, iconPath);
+    return SetXmlImage(*toast_xml, icon_path);
+
+  return true;
 }
 
-        // Don't stop a notification from showing just because an image couldn't be displayed. By default the app icon will be shown.
+bool WindowsToastNotification::SetXmlText(
-        hr = S_OK;
+    IXmlDocument* doc, const std::wstring& text) {
-    }
+  ScopedHString tag;
-
+  ComPtr<IXmlNodeList> node_list;
-    return hr;
+  if (!GetTextNodeList(&tag, doc, &node_list, 1))
-}
+    return false;
-
-HRESULT WindowsToastNotification::SetXmlText(IXmlDocument* doc, const WCHAR* text)
-{
-    HSTRING tag = NULL;
-
-    ComPtr<IXmlNodeList> nodeList;
-    HRESULT hr = GetTextNodeList(&tag, doc, &nodeList, 1);
-    do {
-        BREAK_IF_BAD(hr);
 
   ComPtr<IXmlNode> node;
-        hr = nodeList->Item(0, &node);
+  if (FAILED(node_list->Item(0, &node)))
-        BREAK_IF_BAD(hr);
+    return false;
 
-        hr = AppendTextToXml(doc, node.Get(), text);
+  return AppendTextToXml(doc, node.Get(), text);
-    } while (FALSE);
-
-    if (tag != NULL) {
-        WindowsDeleteString(tag);
 }
 
-    return hr;
+bool WindowsToastNotification::SetXmlText(
-}
+    IXmlDocument* doc, const std::wstring& title, const std::wstring& body) {
-
+  ScopedHString tag;
-HRESULT WindowsToastNotification::SetXmlText(IXmlDocument* doc, const WCHAR* title, const WCHAR* body)
+  ComPtr<IXmlNodeList> node_list;
-{
+  if (!GetTextNodeList(&tag, doc, &node_list, 2))
-    HSTRING tag = NULL;
+    return false;
-    ComPtr<IXmlNodeList> nodeList;
-    HRESULT hr = GetTextNodeList(&tag, doc, &nodeList, 2);
-    do {
-        BREAK_IF_BAD(hr);
 
   ComPtr<IXmlNode> node;
-        hr = nodeList->Item(0, &node);
+  if (FAILED(node_list->Item(0, &node)))
-        BREAK_IF_BAD(hr);
+    return false;
 
-        hr = AppendTextToXml(doc, node.Get(), title);
+  if (!AppendTextToXml(doc, node.Get(), title))
-        BREAK_IF_BAD(hr);
+    return false;
 
-        hr = nodeList->Item(1, &node);
+  if (FAILED(node_list->Item(1, &node)))
-        BREAK_IF_BAD(hr);
+    return false;
 
-        hr = AppendTextToXml(doc, node.Get(), body);
+  return AppendTextToXml(doc, node.Get(), body);
-    } while (FALSE);
-
-    if (tag != NULL) {
-        WindowsDeleteString(tag);
 }
 
-    return hr;
+bool WindowsToastNotification::SetXmlImage(
-}
+    IXmlDocument* doc, std::string icon_path) {
+  ScopedHString tag(L"imag");
+  if (!tag.success())
+    return false;
 
-HRESULT WindowsToastNotification::SetXmlImage(IXmlDocument* doc, std::string iconPath)
+  ComPtr<IXmlNodeList> node_list;
-{
+  if (FAILED(doc->GetElementsByTagName(tag, &node_list)))
-    HSTRING tag = NULL;
+    return false;
-    HSTRING src = NULL;
-    HSTRING imgPath = NULL;
-    HRESULT hr = CreateHString(L"image", &tag);
 
-    do {
+  ComPtr<IXmlNode> image_node;
-        BREAK_IF_BAD(hr);
+  if (FAILED(node_list->Item(0, &image_node)))
-
+    return false;
-        ComPtr<IXmlNodeList> nodeList;
-        hr = doc->GetElementsByTagName(tag, &nodeList);
-        BREAK_IF_BAD(hr);
-
-        ComPtr<IXmlNode> imageNode;
-        hr = nodeList->Item(0, &imageNode);
-        BREAK_IF_BAD(hr);
 
   ComPtr<IXmlNamedNodeMap> attrs;
-        hr = imageNode->get_Attributes(&attrs);
+  if (FAILED(image_node->get_Attributes(&attrs)))
-        BREAK_IF_BAD(hr);
+    return false;
 
-        hr = CreateHString(L"src", &src);
+  ScopedHString src(L"src");
-        BREAK_IF_BAD(hr);
+  if (!src.success())
+    return false;
 
-        ComPtr<IXmlNode> srcAttr;
+  ComPtr<IXmlNode> src_attr;
-        hr = attrs->GetNamedItem(src, &srcAttr);
+  if (FAILED(attrs->GetNamedItem(src, &src_attr)))
-        BREAK_IF_BAD(hr);
+    return false;
 
-        WCHAR xmlPath[MAX_PATH];
+  ScopedHString img_path(base::UTF8ToUTF16(icon_path).c_str());
-        swprintf(xmlPath, ARRAYSIZE(xmlPath), L"%S", iconPath);
+  if (!img_path.success())
-        hr = CreateHString(xmlPath, &imgPath);
+    return false;
-        BREAK_IF_BAD(hr);
 
-        ComPtr<IXmlText> srcText;
+  ComPtr<IXmlText> src_text;
-        hr = doc->CreateTextNode(imgPath, &srcText);
+  if (FAILED(doc->CreateTextNode(img_path, &src_text)))
-        BREAK_IF_BAD(hr);
+    return false;
 
-        ComPtr<IXmlNode> srcNode;
+  ComPtr<IXmlNode> src_node;
-        hr = srcText.As(&srcNode);
+  if (FAILED(src_text.As(&src_node)))
-        BREAK_IF_BAD(hr);
+    return false;
 
-        ComPtr<IXmlNode> childNode;
+  ComPtr<IXmlNode> child_node;
-        hr = srcAttr->AppendChild(srcNode.Get(), &childNode);
+  return SUCCEEDED(src_attr->AppendChild(src_node.Get(), &child_node));
-    } while (FALSE);
-
-    if (tag != NULL) {
-        WindowsDeleteString(tag);
-    }
-    if (src != NULL) {
-        WindowsDeleteString(src);
-    }
-    if (imgPath != NULL) {
-        WindowsDeleteString(imgPath);
 }
 
-    return hr;
+bool WindowsToastNotification::GetTextNodeList(
+    ScopedHString* tag,
+    IXmlDocument* doc,
+    IXmlNodeList** node_list,
+    UINT32 req_length) {
+  tag->Set(L"text");
+  if (!tag->success())
+    return false;
+
+  if (FAILED(doc->GetElementsByTagName(*tag, node_list)))
+    return false;
+
+  UINT32 node_length;
+  if (FAILED((*node_list)->get_Length(&node_length)))
+    return false;
+
+  return node_length >= req_length;
 }
 
-HRESULT WindowsToastNotification::GetTextNodeList(HSTRING* tag, IXmlDocument* doc, IXmlNodeList** nodeList, UINT32 reqLength)
+bool WindowsToastNotification::AppendTextToXml(
-{
+    IXmlDocument* doc, IXmlNode* node, const std::wstring& text) {
-    HRESULT hr = CreateHString(L"text", tag);
+  ScopedHString str(text);
-    do{
+  if (!str.success())
-        BREAK_IF_BAD(hr);
+    return false;
 
-        hr = doc->GetElementsByTagName(*tag, nodeList);
+  ComPtr<IXmlText> xml_text;
-        BREAK_IF_BAD(hr);
+  if (FAILED(doc->CreateTextNode(str, &xml_text)))
+    return false;
 
-        UINT32 nodeLength;
+  ComPtr<IXmlNode> text_node;
-        hr = (*nodeList)->get_Length(&nodeLength);
+  if (FAILED(xml_text.As(&text_node)))
-        BREAK_IF_BAD(hr);
+    return false;
 
-        if (nodeLength < reqLength) {
+  ComPtr<IXmlNode> append_node;
-            hr = E_INVALIDARG;
+  return SUCCEEDED(node->AppendChild(text_node.Get(), &append_node));
-        }
-    } while (FALSE);
-
-    if (!SUCCEEDED(hr)) {
-        // Allow the caller to delete this string on success
-        WindowsDeleteString(*tag);
 }
 
-    return hr;
+bool WindowsToastNotification::SetupCallbacks(IToastNotification* toast) {
-}
-
-HRESULT WindowsToastNotification::AppendTextToXml(IXmlDocument* doc, IXmlNode* node, const WCHAR* text)
-{
-    HSTRING str = NULL;
-    HRESULT hr = CreateHString(text, &str);
-    do {
-        BREAK_IF_BAD(hr);
-
-        ComPtr<IXmlText> xmlText;
-        hr = doc->CreateTextNode(str, &xmlText);
-        BREAK_IF_BAD(hr);
-
-        ComPtr<IXmlNode> textNode;
-        hr = xmlText.As(&textNode);
-        BREAK_IF_BAD(hr);
-
-        ComPtr<IXmlNode> appendNode;
-        hr = node->AppendChild(textNode.Get(), &appendNode);
-    } while (FALSE);
-
-    if (str != NULL) {
-        WindowsDeleteString(str);
-    }
-
-    return hr;
-}
-
-HRESULT WindowsToastNotification::SetupCallbacks(IToastNotification* toast)
-{
   EventRegistrationToken activatedToken, dismissedToken;
-    m_eventHandler = Make<ToastEventHandler>(this, n_delegate);
+  event_handler_ = Make<ToastEventHandler>(this);
-    HRESULT hr = toast->add_Activated(m_eventHandler.Get(), &activatedToken);
+  if (FAILED(toast->add_Activated(event_handler_.Get(), &activatedToken)))
+    return false;
 
-    if (SUCCEEDED(hr)) {
+  return SUCCEEDED(toast->add_Dismissed(event_handler_.Get(), &dismissedToken));
-        hr = toast->add_Dismissed(m_eventHandler.Get(), &dismissedToken);
-    }
-
-    return hr;
-}
-
-HRESULT WindowsToastNotification::CreateHString(const WCHAR* source, HSTRING* dest)
-{
-    if (source == NULL || dest == NULL) {
-        return E_INVALIDARG;
-    }
-
-    HRESULT hr = WindowsCreateString(source, wcslen(source), dest);
-    return hr;
 }
 
 /*
 / Toast Event Handler
 */
-ToastEventHandler::ToastEventHandler(WindowsToastNotification* notification, content::DesktopNotificationDelegate* delegate)
+ToastEventHandler::ToastEventHandler(WindowsToastNotification* notification)
-{
+    : notification_(notification) {
-    m_notification = notification;
-    n_delegate = delegate;
 }
 
-ToastEventHandler::~ToastEventHandler()
+ToastEventHandler::~ToastEventHandler() {
-{
-    // Empty
-}
-
-IFACEMETHODIMP ToastEventHandler::Invoke(IToastNotification* sender, IInspectable* args)
-{
-    // Notification "activated" (clicked)
-    n_delegate->NotificationClick();
-    
-    if (m_notification != NULL) {
-        m_notification->NotificationClicked();
 }
 
+IFACEMETHODIMP ToastEventHandler::Invoke(
+    IToastNotification* sender, IInspectable* args) {
+  notification_->NotificationClicked();
   return S_OK;
 }
 
-IFACEMETHODIMP ToastEventHandler::Invoke(IToastNotification* sender, IToastDismissedEventArgs* e)
+IFACEMETHODIMP ToastEventHandler::Invoke(
-{   
+    IToastNotification* sender, IToastDismissedEventArgs* e) {
-    // Notification dismissed
+  notification_->NotificationDismissed();
-    n_delegate->NotificationClosed();
-
-    if (m_notification != NULL) {
-        m_notification->NotificationDismissed();
-        
-    }
-    
   return S_OK;
 }
 
-} //namespace
+}  // namespace brightray

brightray/browser/win/windows_toast_notification.h

@@ -3,70 +3,102 @@
 // Thanks to both of those folks mentioned above who first thought up a bunch of this code
 // and released it as MIT to the world.
 
-#ifndef __WINDOWS_TOAST_NOTIFICATION_H__
+#ifndef BRIGHTRAY_BROWSER_WIN_WINDOWS_TOAST_NOTIFICATION_H_
-#define __WINDOWS_TOAST_NOTIFICATION_H__
+#define BRIGHTRAY_BROWSER_WIN_WINDOWS_TOAST_NOTIFICATION_H_
-
-#include "content/public/browser/desktop_notification_delegate.h"
-#include "content/public/common/platform_notification_data.h"
-#include "base/bind.h"
 
 #include <windows.h>
 #include <windows.ui.notifications.h>
 #include <wrl/implements.h>
 
+#include "base/bind.h"
+#include "base/memory/weak_ptr.h"
+#include "content/public/browser/desktop_notification_delegate.h"
+#include "content/public/common/platform_notification_data.h"
+
 using namespace Microsoft::WRL;
 using namespace ABI::Windows::UI::Notifications;
 using namespace ABI::Windows::Foundation;
 
-namespace WinToasts {
+class ScopedHString;
 
-    typedef ITypedEventHandler<ToastNotification*, IInspectable*> DesktopToastActivatedEventHandler;
+namespace brightray {
-    typedef ITypedEventHandler<ToastNotification*, ToastDismissedEventArgs*> DesktopToastDismissedEventHandler;
 
-    class ToastEventHandler;
+using DesktopToastActivatedEventHandler =
+    ITypedEventHandler<ToastNotification*, IInspectable*>;
+using DesktopToastDismissedEventHandler =
+    ITypedEventHandler<ToastNotification*, ToastDismissedEventArgs*>;
 
-    class WindowsToastNotification
+class WindowsToastNotification {
-    {
  public:
-        WindowsToastNotification(const char* appName, content::DesktopNotificationDelegate* delegate);
+  WindowsToastNotification(
+      const std::string& app_name,
+      scoped_ptr<content::DesktopNotificationDelegate> delegate);
   ~WindowsToastNotification();
-        void ShowNotification(const WCHAR* title, const WCHAR* msg, std::string iconPath, ComPtr<IToastNotification>& toast);
+
-        void DismissNotification(ComPtr<IToastNotification> toast);
+  void ShowNotification(const std::wstring& title,
+                        const std::wstring& msg,
+                        std::string icon_path);
+  void DismissNotification();
+
+  base::WeakPtr<WindowsToastNotification> GetWeakPtr() {
+    return weak_factory_.GetWeakPtr();
+  }
+
+ private:
+  friend class ToastEventHandler;
+
   void NotificationClicked();
   void NotificationDismissed();
 
-    private:
+  bool GetToastXml(IToastNotificationManagerStatics* toastManager,
-        ComPtr<ToastEventHandler> m_eventHandler;
+                   const std::wstring& title,
+                   const std::wstring& msg,
+                   std::string icon_path,
+                   ABI::Windows::Data::Xml::Dom::IXmlDocument** toastXml);
+  bool SetXmlText(ABI::Windows::Data::Xml::Dom::IXmlDocument* doc,
+                  const std::wstring& text);
+  bool SetXmlText(ABI::Windows::Data::Xml::Dom::IXmlDocument* doc,
+                  const std::wstring& title,
+                  const std::wstring& body);
+  bool SetXmlImage(ABI::Windows::Data::Xml::Dom::IXmlDocument* doc,
+                   std::string icon_path);
+  bool GetTextNodeList(ScopedHString* tag,
+                       ABI::Windows::Data::Xml::Dom::IXmlDocument* doc,
+                       ABI::Windows::Data::Xml::Dom::IXmlNodeList** nodeList,
+                       UINT32 reqLength);
+  bool AppendTextToXml(ABI::Windows::Data::Xml::Dom::IXmlDocument* doc,
+                       ABI::Windows::Data::Xml::Dom::IXmlNode* node,
+                       const std::wstring& text);
+  bool SetupCallbacks(IToastNotification* toast);
 
-        content::DesktopNotificationDelegate* n_delegate;
+  scoped_ptr<content::DesktopNotificationDelegate> delegate_;
-        ComPtr<IToastNotificationManagerStatics> m_toastManager;
+  ComPtr<ToastEventHandler> event_handler_;
-        ComPtr<IToastNotifier> m_toastNotifier;
+  ComPtr<IToastNotificationManagerStatics> toast_manager_;
+  ComPtr<IToastNotifier> toast_notifier_;
+  ComPtr<IToastNotification> toast_notification_;
 
-        HRESULT GetToastXml(IToastNotificationManagerStatics* toastManager, const WCHAR* title, const WCHAR* msg, std::string iconPath, ABI::Windows::Data::Xml::Dom::IXmlDocument** toastXml);
+  base::WeakPtrFactory<WindowsToastNotification> weak_factory_;
-        HRESULT SetXmlText(ABI::Windows::Data::Xml::Dom::IXmlDocument* doc, const WCHAR* text);
+
-        HRESULT SetXmlText(ABI::Windows::Data::Xml::Dom::IXmlDocument* doc, const WCHAR* title, const WCHAR* body);
+  DISALLOW_COPY_AND_ASSIGN(WindowsToastNotification);
-        HRESULT SetXmlImage(ABI::Windows::Data::Xml::Dom::IXmlDocument* doc, std::string iconPath);
-        HRESULT GetTextNodeList(HSTRING* tag, ABI::Windows::Data::Xml::Dom::IXmlDocument* doc, ABI::Windows::Data::Xml::Dom::IXmlNodeList** nodeList, UINT32 reqLength);
-        HRESULT AppendTextToXml(ABI::Windows::Data::Xml::Dom::IXmlDocument* doc, ABI::Windows::Data::Xml::Dom::IXmlNode* node, const WCHAR* text);
-        HRESULT SetupCallbacks(IToastNotification* toast);
-        HRESULT CreateHString(const WCHAR* source, HSTRING* dest);
 };
 
 
-    class ToastEventHandler :
+class ToastEventHandler : public RuntimeClass<RuntimeClassFlags<ClassicCom>,
-        public RuntimeClass<RuntimeClassFlags<ClassicCom>, DesktopToastActivatedEventHandler, DesktopToastDismissedEventHandler>
+                                              DesktopToastActivatedEventHandler,
-    {
+                                              DesktopToastDismissedEventHandler> {
  public:
-        ToastEventHandler(WindowsToastNotification* notification, content::DesktopNotificationDelegate* delegate);
+  ToastEventHandler(WindowsToastNotification* notification);
   ~ToastEventHandler();
+
   IFACEMETHODIMP Invoke(IToastNotification* sender, IInspectable* args);
   IFACEMETHODIMP Invoke(IToastNotification* sender, IToastDismissedEventArgs* e);
 
  private:
-        WindowsToastNotification* m_notification;
+  WindowsToastNotification* notification_;  // weak ref.
-        content::DesktopNotificationDelegate* n_delegate;
+
+  DISALLOW_COPY_AND_ASSIGN(ToastEventHandler);
 };
 
-} // namespace
+}  // namespace brightray
 
-#endif //__WINDOWS_TOAST_NOTIFICATION_H__
+#endif  // BRIGHTRAY_BROWSER_WIN_WINDOWS_TOAST_NOTIFICATION_H_

brightray/filenames.gypi

@@ -67,6 +67,8 @@
       'browser/win/notification_presenter_win.cc',
       'browser/win/windows_toast_notification.h',
       'browser/win/windows_toast_notification.cc',
+      'browser/win/scoped_hstring.h',
+      'browser/win/scoped_hstring.cc',
       'browser/special_storage_policy.cc',
       'browser/special_storage_policy.h',
       'browser/url_request_context_getter.cc',