Merge lp:~zaspire/oxide/web-notifications_v2 into lp:~oxide-developers/oxide/oxide.trunk

[Maxim Ermilov]

[Maxim Ermilov (zaspire)]

this work is required for PushNotifications.

[Chris Coulson (chrisccoulson)]

Ok, I've reviewed this again.

There's also quite a few cases missing in the tests - please take a look at the geolocation permission tests.

Also, we should figure out a way to test the actual libnotify integration (I'm not sure of the best way to do that, but it shouldn't be too difficult to mock).

review: Needs Fixing

[Maxim Ermilov (zaspire)]

tests with mocked libnotify wrapper will go as separate merge request.

=== modified file 'build/system.gyp'
--- build/system.gyp	2015-01-21 23:40:11 +0000
+++ build/system.gyp	2015-06-19 15:52:24 +0000
@@ -18,6 +18,25 @@
   'variables': {
     'pkg_config': 'pkg-config'
   },
+  'targets': [
+    {
+      'target_name': 'libnotify',
+      'type': 'none',
+      'direct_dependent_settings': {
+        'cflags_cc': [
+          '<!@(<(pkg_config) --cflags libnotify)'
+        ]
+      },
+      'link_settings': {
+        'ldflags': [
+          '<!@(<(pkg_config) --libs-only-L --libs-only-other libnotify)',
+        ],
+        'libraries': [
+          '<!@(<(pkg_config) --libs-only-l libnotify)',
+        ],
+      },
+    },
+  ],
   'conditions': [
     ['target_arch=="arm"', {
       'targets': [

=== modified file 'qt/core/browser/oxide_qt_browser_platform_integration.cc'
--- qt/core/browser/oxide_qt_browser_platform_integration.cc	2015-06-12 07:39:38 +0000
+++ qt/core/browser/oxide_qt_browser_platform_integration.cc	2015-06-19 15:52:24 +0000
@@ -161,6 +161,11 @@
   return state_;
 }
 
+std::string
+BrowserPlatformIntegration::GetAppName() {
+  return QCoreApplication::applicationName().toStdString();
+}
+
 bool BrowserPlatformIntegration::eventFilter(QObject* watched, QEvent* event) {
   if (event->type() == QEvent::ApplicationActivate ||
       event->type() == QEvent::ApplicationDeactivate) {

=== modified file 'qt/core/browser/oxide_qt_browser_platform_integration.h'
--- qt/core/browser/oxide_qt_browser_platform_integration.h	2015-06-12 07:39:38 +0000
+++ qt/core/browser/oxide_qt_browser_platform_integration.h	2015-06-19 15:52:24 +0000
@@ -57,6 +57,7 @@
   void BrowserThreadInit(content::BrowserThread::ID id) override;
   content::LocationProvider* CreateLocationProvider() override;
   ApplicationState GetApplicationState() override;
+  std::string GetAppName() override;
   ui::ClipboardOxideFactory GetClipboardOxideFactory() override;
 
   // QObject implementation

=== modified file 'qt/core/browser/oxide_qt_web_view.cc'
--- qt/core/browser/oxide_qt_web_view.cc	2015-06-04 17:11:01 +0000
+++ qt/core/browser/oxide_qt_web_view.cc	2015-06-19 15:52:24 +0000
@@ -1011,6 +1011,16 @@
   client_->RequestGeolocationPermission(req.release());
 }
 
+void WebView::RequestNotificationPermission(
+    scoped_ptr<oxide::SimplePermissionRequest> request) {
+  scoped_ptr<OxideQSimplePermissionRequest> req(
+      OxideQSimplePermissionRequestPrivate::Create(
+        request.Pass()));
+
+  // The embedder takes ownership of this
+  client_->RequestNotificationPermission(req.release());
+}
+
 void WebView::RequestMediaAccessPermission(
     scoped_ptr<oxide::MediaAccessPermissionRequest> request) {
   scoped_ptr<OxideQMediaAccessPermissionRequest> req(

=== modified file 'qt/core/browser/oxide_qt_web_view.h'
--- qt/core/browser/oxide_qt_web_view.h	2015-06-04 13:21:49 +0000
+++ qt/core/browser/oxide_qt_web_view.h	2015-06-19 15:52:24 +0000
@@ -177,6 +177,8 @@
   // oxide::PermissionRequestDispatcherClient implementation
   void RequestGeolocationPermission(
       scoped_ptr<oxide::SimplePermissionRequest> request) override;
+  void RequestNotificationPermission(
+      scoped_ptr<oxide::SimplePermissionRequest> request) override;
   void RequestMediaAccessPermission(
       scoped_ptr<oxide::MediaAccessPermissionRequest> request) override;
 

=== modified file 'qt/core/glue/oxide_qt_web_view_proxy_client.h'
--- qt/core/glue/oxide_qt_web_view_proxy_client.h	2015-05-27 20:56:59 +0000
+++ qt/core/glue/oxide_qt_web_view_proxy_client.h	2015-06-19 15:52:24 +0000
@@ -32,6 +32,7 @@
 class OxideQMediaAccessPermissionRequest;
 class OxideQNavigationRequest;
 class OxideQNewViewRequest;
+class OxideQSimplePermissionRequest;
 
 QT_BEGIN_NAMESPACE
 class QCursor;
@@ -128,6 +129,8 @@
       OxideQGeolocationPermissionRequest* request) = 0;
   virtual void RequestMediaAccessPermission(
       OxideQMediaAccessPermissionRequest* request) = 0;
+  virtual void RequestNotificationPermission(
+      OxideQSimplePermissionRequest* request) = 0;
 
   virtual void HandleUnhandledKeyboardEvent(QKeyEvent* event) = 0;
 

=== modified file 'qt/qmlplugin/oxide_qml_plugin.cc'
--- qt/qmlplugin/oxide_qml_plugin.cc	2015-06-05 18:43:21 +0000
+++ qt/qmlplugin/oxide_qml_plugin.cc	2015-06-19 15:52:24 +0000
@@ -134,6 +134,7 @@
     qmlRegisterUncreatableType<OxideQLoadEvent, 2>(uri, 1, 8, "LoadEvent",
         "LoadEvent is delivered by WebView.loadEvent");
     qmlRegisterType<OxideQQuickWebView, 4>(uri, 1, 8, "WebView");
+    qmlRegisterType<OxideQQuickWebView, 5>(uri, 1, 8, "WebView");
 
     qmlRegisterType<OxideQQuickWebContext, 3>(uri, 1, 9, "WebContext");
   }

=== modified file 'qt/quick/api/oxideqquickwebview.cc'
--- qt/quick/api/oxideqquickwebview.cc	2015-05-28 23:51:39 +0000
+++ qt/quick/api/oxideqquickwebview.cc	2015-06-19 15:52:24 +0000
@@ -461,6 +461,29 @@
 
 }
 
+void OxideQQuickWebViewPrivate::RequestNotificationPermission(
+    OxideQSimplePermissionRequest* request) {
+  Q_Q(OxideQQuickWebView);
+
+  QQmlEngine* engine = qmlEngine(q);
+  if (!engine) {
+    delete request;
+    return;
+  }
+
+  {
+    QJSValue val = engine->newQObject(request);
+    if (!val.isQObject()) {
+      delete request;
+      return;
+    }
+
+    emit q->notificationPermissionRequested(val);
+  }
+
+  engine->collectGarbage();
+}
+
 void OxideQQuickWebViewPrivate::HandleUnhandledKeyboardEvent(
     QKeyEvent* event) {
   Q_Q(OxideQQuickWebView);

=== modified file 'qt/quick/api/oxideqquickwebview_p.h'
--- qt/quick/api/oxideqquickwebview_p.h	2015-05-28 23:51:39 +0000
+++ qt/quick/api/oxideqquickwebview_p.h	2015-06-19 15:52:24 +0000
@@ -345,6 +345,7 @@
   void navigationRequested(OxideQNavigationRequest* request);
   void newViewRequested(OxideQNewViewRequest* request);
   void geolocationPermissionRequested(const QJSValue& request);
+  Q_REVISION(5) void notificationPermissionRequested(const QJSValue& request);
   Q_REVISION(4) void mediaAccessPermissionRequested(const QJSValue& request);
   void javaScriptConsoleMessage(LogMessageSeverityLevel level,
                                 const QString& message,

=== modified file 'qt/quick/api/oxideqquickwebview_p_p.h'
--- qt/quick/api/oxideqquickwebview_p_p.h	2015-05-28 23:51:39 +0000
+++ qt/quick/api/oxideqquickwebview_p_p.h	2015-06-19 15:52:24 +0000
@@ -128,6 +128,9 @@
       OxideQGeolocationPermissionRequest* request) override;
   void RequestMediaAccessPermission(
       OxideQMediaAccessPermissionRequest* request) override;
+  void RequestNotificationPermission(
+      OxideQSimplePermissionRequest* request) override;
+
   void HandleUnhandledKeyboardEvent(QKeyEvent *event) override;
   void FrameMetadataUpdated(
       oxide::qt::FrameMetadataChangeFlags flags) override;

=== added file 'qt/tests/qmltests/api/tst_WebNotificationPermissionRequest.html'
--- qt/tests/qmltests/api/tst_WebNotificationPermissionRequest.html	1970-01-01 00:00:00 +0000
+++ qt/tests/qmltests/api/tst_WebNotificationPermissionRequest.html	2015-06-19 15:52:24 +0000
@@ -0,0 +1,21 @@
+<html>
+<body>
+</body>
+<script>
+
+var vgaConstraints = {video: true, audio: true};
+
+function invoke() {
+  Notification.requestPermission(function(permission){
+    if(permission == 'granted'){
+      var e = new CustomEvent("result", { bubbles: true, detail: { status: 0 } });
+      document.documentElement.dispatchEvent(e);
+    } else {
+      var e = new CustomEvent("result", { bubbles: true, detail: { status: 1 } });
+      document.documentElement.dispatchEvent(e);
+    }
+  });
+}
+setTimeout(invoke, 400);
+</script>
+</html>

=== added file 'qt/tests/qmltests/api/tst_WebNotificationPermissionRequest.js'
--- qt/tests/qmltests/api/tst_WebNotificationPermissionRequest.js	1970-01-01 00:00:00 +0000
+++ qt/tests/qmltests/api/tst_WebNotificationPermissionRequest.js	2015-06-19 15:52:24 +0000
@@ -0,0 +1,6 @@
+// ==UserScript==
+// @run-at document-start
+// ==/UserScript==
+document.addEventListener("result", function(event) {
+  oxide.sendMessage("TEST-RESPONSE", { status: event.detail.status });
+});

=== added file 'qt/tests/qmltests/api/tst_WebNotificationPermissionRequest.qml'
--- qt/tests/qmltests/api/tst_WebNotificationPermissionRequest.qml	1970-01-01 00:00:00 +0000
+++ qt/tests/qmltests/api/tst_WebNotificationPermissionRequest.qml	2015-06-19 15:52:24 +0000
@@ -0,0 +1,198 @@
+import QtQuick 2.0
+import QtTest 1.0
+import com.canonical.Oxide 1.8
+import com.canonical.Oxide.Testing 1.0
+
+Item {
+  width: 200
+  height: 200
+
+  SignalSpy {
+    id: spy
+    signalName: "notificationPermissionRequested"
+  }
+
+  Component {
+    id: userScriptFactory
+    UserScript {}
+  }
+
+  TestWebContext {
+    id: c
+    Component.onCompleted: {
+      var script = userScriptFactory.createObject(null, {
+          context: "oxide://testutils/",
+          url: Qt.resolvedUrl("tst_WebNotificationPermissionRequest.js"),
+          matchAllFrames: true
+      });
+      addUserScript(script);
+    }
+  }
+
+  Component {
+    id: webViewFactory
+    TestWebView {
+      context: c
+
+      property var lastRequest: null
+      onNotificationPermissionRequested: {
+        lastRequest = request;
+      }
+
+      QtObject {
+        id: _internal
+        property var lastStatus: -1
+      }
+      property alias lastStatus: _internal.lastStatus
+
+      messageHandlers: [
+        ScriptMessageHandler {
+          msgId: "TEST-RESPONSE"
+          contexts: [ "oxide://testutils/" ]
+          callback: function(msg) {
+            _internal.lastStatus = msg.args.status;
+          }
+        }
+      ]
+    }
+  }
+
+  TestCase {
+    id: test
+    name: "NotificationPermissionRequest_session_persist"
+    when: windowShown
+
+    function _test_accept(req) {
+      req.allow();
+    }
+
+    function _test_deny(req) {
+      req.deny();
+    }
+
+    function _test_destroy(req) {
+      req.destroy();
+    }
+
+    function init() {
+      spy.target = null;
+      spy.clear();
+      c.clearTemporarySavedPermissionStatuses();
+    }
+
+    function test_NotificationPermissionRequest_session_persist1_data() {
+      return [
+        { function: _test_accept, expected: 0, save: true },
+        { function: _test_deny, expected: 1, save: true },
+        { function: _test_destroy, expected: 1, save: false },
+      ];
+    }
+
+    function test_NotificationPermissionRequest_session_persist1(data) {
+      var webView = webViewFactory.createObject(null, {});
+      spy.target = webView;
+
+      webView.url = "http://foo.testsuite/tst_WebNotificationPermissionRequest.html";
+
+      verify(webView.waitForLoadSucceeded());
+
+      spy.wait();
+
+      compare(webView.lastRequest.embedder, "http://foo.testsuite/");
+
+      data.function(webView.lastRequest);
+
+      verify(webView.waitFor(function() { return webView.lastStatus != -1; }));
+      compare(webView.lastStatus, data.expected);
+
+      spy.clear();
+      webView.lastStatus = -1;
+
+      webView.reload();
+      verify(webView.waitForLoadSucceeded());
+
+      if (data.save) {
+        verify(webView.waitFor(function() { return webView.lastStatus != -1; }));
+        compare(webView.lastStatus, data.expected);
+      } else {
+        spy.wait();
+        compare(webView.lastRequest.embedder, "http://foo.testsuite/");
+      }
+    }
+
+    function test_NotificationPermissionRequest_session_persist2_data() {
+      return test_NotificationPermissionRequest_session_persist1_data();
+    }
+
+    function test_NotificationPermissionRequest_session_persist2(data) {
+      var webView = webViewFactory.createObject(null, {});
+      spy.target = webView;
+
+      webView.url = "http://foo.testsuite/tst_WebNotificationPermissionRequest.html";
+      verify(webView.waitForLoadSucceeded());
+
+      spy.wait();
+
+      compare(webView.lastRequest.embedder, "http://foo.testsuite/");
+
+      data.function(webView.lastRequest);
+
+      verify(webView.waitFor(function() { return webView.lastStatus != -1; }));
+      compare(webView.lastStatus, data.expected);
+
+      webView = webViewFactory.createObject(null, {});
+      spy.target = webView;
+
+      spy.clear();
+
+      webView.url = "http://foo.testsuite/tst_WebNotificationPermissionRequest.html";
+      verify(webView.waitForLoadSucceeded());
+
+      if (data.save) {
+        verify(webView.waitFor(function() { return webView.lastStatus != -1; }));
+        compare(webView.lastStatus, data.expected);
+      } else {
+        spy.wait();
+        compare(webView.lastRequest.embedder, "http://foo.testsuite/");
+      }
+    }
+
+    function test_NotificationPermissionRequest_session_persist3_data() {
+      return [
+        // Same origin / different embedder
+        { url1: "http://foo.testsuite/tst_WebNotificationPermissionRequest.html",
+          url2: "http://bar.testsuite/tst_WebNotificationPermissionRequest.html" },
+        // Same origin / embedder == allowed origin
+        { url1: "http://foo.testsuite/tst_WebNotificationPermissionRequest.html",
+          url2: "http://testsuite/tst_WebNotificationPermissionRequest.html" },
+        // Different origin / different embedder
+        { url1: "http://foo.testsuite/tst_WebNotificationPermissionRequest.html",
+          url2: "http://bar.testsuite/tst_WebNotificationPermissionRequest.html" },
+      ];
+    }
+
+    // Verify several cases where saved permissions should not be used
+    function test_NotificationPermissionRequest_session_persist3(data) {
+      var webView = webViewFactory.createObject(null, {});
+      spy.target = webView;
+
+      webView.url = data.url1;
+      verify(webView.waitForLoadSucceeded());
+
+      spy.wait();
+
+      webView.lastRequest.allow();
+
+      verify(webView.waitFor(function() { return webView.lastStatus != -1; }));
+      compare(webView.lastStatus, 0);
+
+      spy.clear();
+      webView.lastStatus = -1;
+
+      webView.url = data.url2;
+      verify(webView.waitForLoadSucceeded());
+
+      spy.wait();
+    }
+  }
+}

=== modified file 'shared/browser/oxide_browser_platform_integration.h'
--- shared/browser/oxide_browser_platform_integration.h	2015-06-12 07:39:38 +0000
+++ shared/browser/oxide_browser_platform_integration.h	2015-06-19 15:52:24 +0000
@@ -96,6 +96,8 @@
   // Get the current application state
   virtual ApplicationState GetApplicationState();
 
+  virtual std::string GetAppName() = 0;
+
  protected:
   BrowserPlatformIntegration();
 

=== modified file 'shared/browser/oxide_content_browser_client.cc'
--- shared/browser/oxide_content_browser_client.cc	2015-06-18 15:48:50 +0000
+++ shared/browser/oxide_content_browser_client.cc	2015-06-19 15:52:24 +0000
@@ -52,6 +52,7 @@
 #include "oxide_web_preferences.h"
 #include "oxide_web_view.h"
 #include "oxide_web_view_contents_helper.h"
+#include "oxide_platform_notification_service.h"
 
 #if defined(ENABLE_PLUGINS)
 #include "content/public/browser/browser_ppapi_host.h"
@@ -298,7 +299,14 @@
     const std::string& application_locale,
     BrowserPlatformIntegration* integration)
     : application_locale_(application_locale),
-      platform_integration_(integration) {}
+      platform_integration_(integration) {
+  PlatformNotificationService::GetInstance()->Initialize(integration->GetAppName());
+}
+
+content::PlatformNotificationService*
+ContentBrowserClient::GetPlatformNotificationService() {
+  return PlatformNotificationService::GetInstance();
+}
 
 ContentBrowserClient::~ContentBrowserClient() {}
 

=== modified file 'shared/browser/oxide_content_browser_client.h'
--- shared/browser/oxide_content_browser_client.h	2015-06-17 21:04:11 +0000
+++ shared/browser/oxide_content_browser_client.h	2015-06-19 15:52:24 +0000
@@ -49,6 +49,7 @@
  private:
   // content::ContentBrowserClient implementation
   std::string GetApplicationLocale() final;
+  content::PlatformNotificationService* GetPlatformNotificationService() final;
   content::BrowserMainParts* CreateBrowserMainParts(
       const content::MainFunctionParams& parameters) final;
   void RenderProcessWillLaunch(content::RenderProcessHost* host) final;

=== added file 'shared/browser/oxide_platform_notification_service.cc'
--- shared/browser/oxide_platform_notification_service.cc	1970-01-01 00:00:00 +0000
+++ shared/browser/oxide_platform_notification_service.cc	2015-06-19 15:52:24 +0000
@@ -0,0 +1,265 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2014 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#include "oxide_platform_notification_service.h"
+
+#include <map>
+#include <libnotify/notify.h>
+#include "third_party/skia/include/core/SkImageEncoder.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+
+#include "base/strings/utf_string_conversions.h"
+#include "content/public/common/platform_notification_data.h"
+#include "content/public/browser/desktop_notification_delegate.h"
+#include "third_party/skia/include/core/SkUnPreMultiply.h"
+
+#include "shared/browser/permissions/oxide_temporary_saved_permission_context.h"
+#include "shared/browser/oxide_browser_context.h"
+
+namespace oxide {
+
+// Copy&paste from chrome/browser/ui/libgtk2ui/skia_utils_gtk2.cc
+// to avoid dependency on full Gdk.
+GdkPixbuf* GdkPixbufFromSkBitmap(const SkBitmap& bitmap) {
+  if (bitmap.isNull()) {
+    return nullptr;
+  }
+
+  SkAutoLockPixels lock_pixels(bitmap);
+
+  int width = bitmap.width();
+  int height = bitmap.height();
+
+  GdkPixbuf* pixbuf =
+      gdk_pixbuf_new(GDK_COLORSPACE_RGB,  // The only colorspace gtk supports.
+                     TRUE,                // There is an alpha channel.
+                     8,
+                     width,
+                     height);
+
+  // SkBitmaps are premultiplied, we need to unpremultiply them.
+  const int kBytesPerPixel = 4;
+  uint8_t* divided = gdk_pixbuf_get_pixels(pixbuf);
+
+  for (int y = 0, i = 0; y < height; y++) {
+    for (int x = 0; x < width; x++) {
+      uint32_t pixel = bitmap.getAddr32(0, y)[x];
+
+      int alpha = SkColorGetA(pixel);
+      if (alpha != 0 && alpha != 255) {
+        SkColor unmultiplied = SkUnPreMultiply::PMColorToColor(pixel);
+        divided[i + 0] = SkColorGetR(unmultiplied);
+        divided[i + 1] = SkColorGetG(unmultiplied);
+        divided[i + 2] = SkColorGetB(unmultiplied);
+        divided[i + 3] = alpha;
+      } else {
+        divided[i + 0] = SkColorGetR(pixel);
+        divided[i + 1] = SkColorGetG(pixel);
+        divided[i + 2] = SkColorGetB(pixel);
+        divided[i + 3] = alpha;
+      }
+      i += kBytesPerPixel;
+    }
+  }
+
+  return pixbuf;
+}
+
+
+namespace {
+
+blink::WebNotificationPermission
+ToNotificationPermission(TemporarySavedPermissionStatus status) {
+  switch (status) {
+  case TEMPORARY_SAVED_PERMISSION_STATUS_ALLOWED:
+    return blink::WebNotificationPermissionAllowed;
+  case TEMPORARY_SAVED_PERMISSION_STATUS_DENIED:
+    return blink::WebNotificationPermissionDenied;
+  default:
+    return blink::WebNotificationPermissionDefault;
+  };
+}
+
+class DesktopNotification: public base::RefCounted<DesktopNotification> {
+public:
+  base::Closure* GetCancelCallback();
+
+  static scoped_refptr<DesktopNotification> CreateDesktopNotification(
+      const GURL& origin, const std::string &tag);
+  void Initialize(
+      const base::string16& title, const base::string16& body,
+      const SkBitmap& icon,
+      scoped_ptr<content::DesktopNotificationDelegate> delegate);
+private:
+  DesktopNotification(const GURL &origin, const std::string &tag);
+  ~DesktopNotification();
+
+  void CancelNotification();
+
+  GURL origin_;
+  std::string tag_;
+  base::Closure cancel_callback_;
+  NotifyNotification *notification_;
+  scoped_ptr<content::DesktopNotificationDelegate> delegate_;
+
+  static void OnClosed(NotifyNotification *notification, DesktopNotification *self);
+  static std::map<GURL, std::map<std::string, scoped_refptr<DesktopNotification>>> table_;
+
+  friend class base::RefCounted<DesktopNotification>;
+};
+
+std::map<GURL, std::map<std::string, scoped_refptr<DesktopNotification>>> DesktopNotification::table_;
+
+DesktopNotification::DesktopNotification(const GURL &origin, const std::string &tag)
+  : origin_(origin), tag_(tag), notification_(nullptr) {
+}
+
+scoped_refptr<DesktopNotification>
+DesktopNotification::CreateDesktopNotification(const GURL& origin, const std::string &tag) {
+  table_[origin][tag] = new DesktopNotification(origin, tag);
+  return table_[origin][tag];
+}
+
+void
+DesktopNotification::Initialize(
+    const base::string16& title, const base::string16& body,
+    const SkBitmap& icon,
+    scoped_ptr<content::DesktopNotificationDelegate> delegate) {
+  DCHECK(!notification_);
+
+  delegate_ = delegate.Pass();
+
+  std::string t = base::UTF16ToUTF8(title);
+  std::string b = base::UTF16ToUTF8(body);
+
+  notification_ = notify_notification_new(t.c_str(), b.c_str(), nullptr);
+
+  g_signal_connect(notification_, "closed", G_CALLBACK(OnClosed), this);
+
+  if (delegate_.get()) {
+    delegate_->NotificationDisplayed();
+  }
+
+  if (icon.width() && icon.height()) {
+    GdkPixbuf *pix = GdkPixbufFromSkBitmap(icon);
+    notify_notification_set_image_from_pixbuf(notification_, pix);
+    g_object_unref(G_OBJECT(pix));
+  }
+  notify_notification_show(notification_, nullptr);
+}
+
+base::Closure*
+DesktopNotification::GetCancelCallback() {
+  cancel_callback_ = base::Bind(&DesktopNotification::CancelNotification, this);
+  return &cancel_callback_;
+}
+
+DesktopNotification::~DesktopNotification() {
+  g_object_unref(G_OBJECT(notification_));
+}
+
+void
+DesktopNotification::CancelNotification() {
+  table_[origin_].erase(tag_);
+  this->Release();
+}
+
+void
+DesktopNotification::OnClosed(NotifyNotification *notification, DesktopNotification *self) {
+  table_[self->origin_].erase(self->tag_);
+  if (self->delegate_.get()) {
+    self->delegate_->NotificationClosed();
+  }
+  self->Release();
+}
+
+}
+
+void
+PlatformNotificationService::Initialize(const std::string& name) {
+  notify_init(name.c_str());
+}
+
+blink::WebNotificationPermission
+PlatformNotificationService::CheckPermissionOnIOThread(
+    content::ResourceContext* resource_context,
+    const GURL& origin,
+    int render_process_id) {
+  TemporarySavedPermissionContext* permission_context =
+    BrowserContextIOData::FromResourceContext(resource_context)->GetTemporarySavedPermissionContext();
+
+  return ToNotificationPermission(permission_context->GetPermissionStatus(
+           TEMPORARY_SAVED_PERMISSION_TYPE_NOTIFICATIONS, origin, origin));
+}
+
+blink::WebNotificationPermission
+PlatformNotificationService::CheckPermissionOnUIThread(
+    content::BrowserContext* browser_context,
+    const GURL& origin,
+    int render_process_id) {
+  BrowserContext* context = static_cast<BrowserContext*>(browser_context);
+  TemporarySavedPermissionContext* permission_context = context->GetTemporarySavedPermissionContext();
+
+  return ToNotificationPermission(permission_context->GetPermissionStatus(
+           TEMPORARY_SAVED_PERMISSION_TYPE_NOTIFICATIONS, origin, origin));
+}
+
+void
+PlatformNotificationService::DisplayNotification(
+    content::BrowserContext* browser_context,
+    const GURL& origin,
+    const SkBitmap& icon,
+    const content::PlatformNotificationData& notification_data,
+    scoped_ptr<content::DesktopNotificationDelegate> delegate,
+    base::Closure* cancel_callback) {
+
+  scoped_refptr<DesktopNotification> notification = DesktopNotification::CreateDesktopNotification(
+    origin, notification_data.tag);
+  notification->Initialize(notification_data.title, notification_data.body, icon, delegate.Pass());
+
+  cancel_callback = notification->GetCancelCallback();
+}
+
+void
+PlatformNotificationService::DisplayPersistentNotification(
+    content::BrowserContext* browser_context,
+    int64 service_worker_registration_id,
+    const GURL& origin,
+    const SkBitmap& icon,
+    const content::PlatformNotificationData& notification_data) {
+  NOTIMPLEMENTED();
+}
+
+void
+PlatformNotificationService::ClosePersistentNotification(content::BrowserContext* browser_context,
+    int64_t persistent_notification_id) {
+  NOTIMPLEMENTED();
+}
+
+bool
+PlatformNotificationService::GetDisplayedPersistentNotifications(
+    content::BrowserContext* browser_context,
+    std::set<std::string>* displayed_notifications) {
+  return false;
+}
+
+PlatformNotificationService*
+PlatformNotificationService::GetInstance() {
+  return Singleton<PlatformNotificationService>::get();
+}
+
+}

=== added file 'shared/browser/oxide_platform_notification_service.h'
--- shared/browser/oxide_platform_notification_service.h	1970-01-01 00:00:00 +0000
+++ shared/browser/oxide_platform_notification_service.h	2015-06-19 15:52:24 +0000
@@ -0,0 +1,77 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2014 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#ifndef _OXIDE_QT_CORE_PLATFORM_NOTIFICATION_H_
+#define _OXIDE_QT_CORE_PLATFORM_NOTIFICATION_H_
+
+#include <string>
+
+#include "base/memory/singleton.h"
+#include "base/values.h"
+#include "content/public/browser/platform_notification_service.h"
+
+namespace oxide {
+
+class PlatformNotificationService: public content::PlatformNotificationService {
+public:
+  void Initialize(const std::string &name);
+
+  blink::WebNotificationPermission CheckPermissionOnIOThread(
+      content::ResourceContext* resource_context,
+      const GURL& origin,
+      int render_process_id) override;
+
+  blink::WebNotificationPermission CheckPermissionOnUIThread(
+      content::BrowserContext* browser_context,
+      const GURL& origin,
+      int render_process_id) override;
+
+  void DisplayNotification(
+      content::BrowserContext* browser_context,
+      const GURL& origin,
+      const SkBitmap& icon,
+      const content::PlatformNotificationData& notification_data,
+      scoped_ptr<content::DesktopNotificationDelegate> delegate,
+      base::Closure* cancel_callback) override;
+
+  void DisplayPersistentNotification(
+      content::BrowserContext* browser_context,
+      int64 service_worker_registration_id,
+      const GURL& origin,
+      const SkBitmap& icon,
+      const content::PlatformNotificationData& notification_data) override;
+
+  void ClosePersistentNotification(
+      content::BrowserContext* browser_context,
+      int64_t persistent_notification_id) override;
+
+  bool GetDisplayedPersistentNotifications(
+      content::BrowserContext* browser_context,
+      std::set<std::string>* displayed_notifications) override;
+
+  static PlatformNotificationService* GetInstance();
+private:
+  friend struct DefaultSingletonTraits<PlatformNotificationService>;
+  PlatformNotificationService() = default;
+
+  DISALLOW_COPY_AND_ASSIGN(PlatformNotificationService);
+};
+
+
+}
+
+#endif

=== modified file 'shared/browser/oxide_web_view.cc'
--- shared/browser/oxide_web_view.cc	2015-06-18 15:48:50 +0000
+++ shared/browser/oxide_web_view.cc	2015-06-19 15:52:24 +0000
@@ -1271,7 +1271,7 @@
   DCHECK(root_frame_.get());
 
   if (params->context && init_data_->load_params) {
-    web_contents_->GetController().LoadURLWithParams(*init_data_->load_params);    
+    web_contents_->GetController().LoadURLWithParams(*init_data_->load_params);
   }
 
   web_contents_->GetController().LoadIfNecessary();

=== modified file 'shared/browser/permissions/oxide_permission_manager.cc'
--- shared/browser/permissions/oxide_permission_manager.cc	2015-06-17 21:04:11 +0000
+++ shared/browser/permissions/oxide_permission_manager.cc	2015-06-19 15:52:24 +0000
@@ -21,6 +21,7 @@
 #include "content/public/browser/geolocation_provider.h"
 #include "content/public/browser/permission_type.h"
 #include "content/public/common/permission_status.mojom.h"
+#include "shared/browser/oxide_platform_notification_service.h"
 
 #include "shared/browser/oxide_browser_context.h"
 
@@ -57,6 +58,7 @@
 bool IsPermissionTypeSupported(content::PermissionType permission) {
   switch (permission) {
     case content::PermissionType::GEOLOCATION:
+    case content::PermissionType::NOTIFICATIONS:
       return true;
     default:
       return false;
@@ -68,6 +70,8 @@
   switch (permission) {
     case content::PermissionType::GEOLOCATION:
       return TEMPORARY_SAVED_PERMISSION_TYPE_GEOLOCATION;
+    case content::PermissionType::NOTIFICATIONS:
+      return TEMPORARY_SAVED_PERMISSION_TYPE_NOTIFICATIONS;
     default:
       NOTREACHED();
       // XXX(chrisccoulson): Perhaps we need __builtin_unreachable here?
@@ -134,6 +138,7 @@
     case content::PermissionType::GEOLOCATION:
       return base::Bind(&RespondToGeolocationPermissionRequest,
                         wrapped_callback);
+    case content::PermissionType::NOTIFICATIONS:
     default:
       return wrapped_callback;
   }

=== modified file 'shared/browser/permissions/oxide_permission_request_dispatcher.cc'
--- shared/browser/permissions/oxide_permission_request_dispatcher.cc	2015-06-17 21:04:11 +0000
+++ shared/browser/permissions/oxide_permission_request_dispatcher.cc	2015-06-19 15:52:24 +0000
@@ -140,6 +140,9 @@
     case content::PermissionType::GEOLOCATION:
       client_->RequestGeolocationPermission(request.Pass());
       break;
+    case content::PermissionType::NOTIFICATIONS:
+      client_->RequestNotificationPermission(request.Pass());
+      break;
     default:
       NOTIMPLEMENTED();
       break;

=== modified file 'shared/browser/permissions/oxide_permission_request_dispatcher_client.h'
--- shared/browser/permissions/oxide_permission_request_dispatcher_client.h	2015-06-04 08:35:28 +0000
+++ shared/browser/permissions/oxide_permission_request_dispatcher_client.h	2015-06-19 15:52:24 +0000
@@ -38,6 +38,9 @@
 
   virtual void RequestMediaAccessPermission(
       scoped_ptr<MediaAccessPermissionRequest> request) {}
+
+  virtual void RequestNotificationPermission(
+      scoped_ptr<SimplePermissionRequest> request) {}
 };
 
 } // namespace oxide

=== modified file 'shared/browser/permissions/oxide_temporary_saved_permission_context.h'
--- shared/browser/permissions/oxide_temporary_saved_permission_context.h	2015-06-10 13:10:39 +0000
+++ shared/browser/permissions/oxide_temporary_saved_permission_context.h	2015-06-19 15:52:24 +0000
@@ -41,6 +41,7 @@
   PERMISSION_TYPES_START,
 
   TEMPORARY_SAVED_PERMISSION_TYPE_GEOLOCATION = PERMISSION_TYPES_START,
+  TEMPORARY_SAVED_PERMISSION_TYPE_NOTIFICATIONS,
   TEMPORARY_SAVED_PERMISSION_TYPE_MEDIA_DEVICE_MIC,
   TEMPORARY_SAVED_PERMISSION_TYPE_MEDIA_DEVICE_CAMERA,
 

=== modified file 'shared/shared.gyp'
--- shared/shared.gyp	2015-06-18 15:48:50 +0000
+++ shared/shared.gyp	2015-06-19 15:52:24 +0000
@@ -17,6 +17,7 @@
 {
   'variables': {
     'grit_out_dir': '<(SHARED_INTERMEDIATE_DIR)/oxide',
+    'pkg_config': 'pkg-config'
   },
   'conditions': [
     ['enable_mediahub==1', {
@@ -264,6 +265,7 @@
         '<(DEPTH)/ui/ozone/ozone.gyp:ozone',
         '<(DEPTH)/url/url.gyp:url_lib',
         '<(DEPTH)/v8/tools/gyp/v8.gyp:v8',
+        '../build/system.gyp:libnotify',
       ],
       'include_dirs': [
         '..',
@@ -357,6 +359,8 @@
         'browser/oxide_message_pump.h',
         'browser/oxide_network_delegate.cc',
         'browser/oxide_network_delegate.h',
+        'browser/oxide_platform_notification_service.h',
+        'browser/oxide_platform_notification_service.cc',
         'browser/oxide_power_save_blocker.cc',
         'browser/oxide_power_save_blocker.h',
         'browser/oxide_quota_permission_context.cc',