Merge lp:~abreu-alexandre/oxide/clipboard into lp:~oxide-developers/oxide/oxide.trunk

[Alexandre Abreu]

Clipboard implementation

Clipboard implementation

[lp:~abreu-alexandre/oxide/clipboard]

1056. By Chris Coulson on 2015-04-28

Fix a memory corruption when the visibilty of a webview is changed

[Chris Coulson (chrisccoulson)]

I haven't given this a proper review yet - I've just left a couple of pointers for implementation changes (quite minor).

Olivier, would you mind taking a look at this if you've got some time?

[Chris Coulson (chrisccoulson)]

review: Needs Fixing

[lp:~abreu-alexandre/oxide/clipboard]

1057. By Chris Coulson on 2015-04-29

Don't crash when the frame tree is torn down during a process swap

1058. By Olivier Tilloy on 2015-04-30

Fix a crash when a popup menu is dismissed twice (by calling accept() and then cancel() on it).

1059. By Olivier Tilloy on 2015-04-30

Fix a crash when a JS dialog is dismissed twice (by calling accept() and then reject() on it).

1060. By Chris Coulson on 2015-05-04

Process all descendents in WebView::FrameDeleted, rather than just the immediate children

1061. By Chris Coulson on 2015-05-04

Don't disable share-group usage if virtualized GL contexts are enabled on desktop. This sucks, as we can't really know why virtualized contexts are enabled - if it's due to performance issues, then using share-groups is ok (and better than the alternative - software compositing). If it's because of driver bugs / crashes, then we're screwed. We need to do this now because Chromium cananry enables virtualized contexts globally on desktop Linux

1062. By Chris Coulson on 2015-05-05

Don't run unload handlers on webviews that are script closed. Also, beef up the tests to catch this and work a bit more reliably

1063. By Chris Coulson on 2015-05-06

Bump Chromium rev to 44.0.2391.0

1064. By Olivier Tilloy on 2015-05-11

Add a WebView::webProcessStatus property to notify embedders when the renderer process crashed or was killed.

1065. By Chris Coulson on 2015-05-11

Add WebView.mediaAccessPermissionRequested API

1066. By Chris Coulson on 2015-05-11

Make comments more accurate

1067. By Chris Coulson on 2015-05-12

FrameTreeNode::frame_tree_node_id is an int rather than int64_t

[Olivier Tilloy (osomon)]

There’s a couple of conflicts in qt/tests/qmltests/oxide_qml_testing_plugin.cc when merging this branch into the latest trunk.

[lp:~abreu-alexandre/oxide/clipboard]

1068. By Chris Coulson on 2015-05-12

Remove a workaround for the old browser headerbar, used when scrolling the focused editable node in to view

1069. By Alexandre Abreu on 2015-05-13

Prevent a shutdown deadlock if the render process is killed whilst waiting for the close ACK

1070. By Chris Coulson on 2015-05-13

When deleting a WebContext, ensure that the service worker context is shut down to release references on the RenderProcessHost

1071. By Chris Coulson on 2015-05-13

Don't leak BrowserContext

1072. By Chris Coulson on 2015-05-13

Fix test failure in tst_OxideGlobal - it seems that the displayName doesn't have extra characters on some machines

1073. By Chris Coulson on 2015-05-13

Ensure we correctly shut down the OTR BrowserContext

[Olivier Tilloy (osomon)]

Thanks for working on this, this is probably the most-awaited feature ever :)
Here are a few comments/remarks from a first round of review:

== unit tests ==

We’re missing unit tests for (at least) HTML markup.

Indentation in qt/tests/qmltests/core/tst_Clipboard.* is inconsistent in places.

Why does clearClipboard() accept an (unused) 'data' parameter?

Is getClipboardImageData() really necessary? Can’t the test data be defined in tst_Clipboard.qml directly (and add a 'data' parameter to copyImageToClipboard())?
In fact, can’t we get rid entirely of copyImageToClipboard(), and make copyToClipboard() more generic by checking the mimeType to decide whether the data is base64-encoded or not?

In test_paste_data(), the 'isimage' parameter seems redundant, you could just verify whether the mimeType starts with "image/".

copyFromClipboard() would be better named getFromClipboard() or getClipboardContent()

> The image we get from QImage and the one we pasted are slightly
> different but overall is the same image. QImage does some "processing"
> on the raw image content that slightly alters it and make it hard to
> have an exact match.
How is that even possible? We’re talking about an uncompressed, lossless PNG, right?
And I don’t see where QImage is involved in test_paste(), only raw data is passed around as QByteArrays.
By the way, can’t we make the test image data smaller? A 1×1 PNG would suffice for testing purposes.

test_copy() seems to be text-specific, so I don’t really see the point of having it being data-driven.

== implementation ==

There is a leftover DLOG in shared/port/ui_base/clipboard_oxide.cc.

Includes are not properly sorted alphabetically in shared/port/ui_base/clipboard_oxide.cc.

In qt/core/browser/oxide_qt_clipboard.cc, Qt includes are not sorted alphabetically. Also QDebug is included but doesn’t appear to be used. Shouldn’t it be used instead of LOG() macros?

In ClipboardQt’s method implementations, isn’t the DCHECK(clipboard) redundant, given that the case where clipboard is null is explictly handled?

Same for a DCHECK(data) in ClipboardQt::IsFormatAvailable(…).

In ClipboardQt::ReadAvailableTypes():
  - instead of a if() followed by a NOTREACHED, wouldn’t a DCHECK be more appropriate? We don’t expect the caller to pass in null parameters anyway, do we?
  - why not push types directly to the passed vector, instead of using an temporary vector and swapping its contents afterwards?
  - shouldn’t contains_filenames be set accordingly if one of the formats is "chromium/filename" ?

The indentation of the definition of ClipboardQt::ReadAsciiText() is incorrect.

It looks like the following block is repeated many times, maybe it could be factored out as a macro?
  const QMimeData *data =
    clipboard->mimeData(
       type == ui::CLIPBOARD_TYPE_COPY_PASTE ?
       QClipboard::Clipboard
       : QClipboard::Selection);

In ClipboardQt::ReadHTML():
  - please use curly brackets to surround the contents of an if() block, even if it’s a one-liner.
  - do we really need to clear markup and src_url prior to setting their content?

In ClipboardQt::ReadImage():
  - I don’t understand the comment about ReadImage. Can you clarif...

review: Needs Fixing

[lp:~abreu-alexandre/oxide/clipboard]

1074. By Chris Coulson on 2015-05-14

Move gesture detection to RWHV, keep MotionEvent tracking on WebView (so that we keep it in sync with incoming touch events), and reset the gesture pipeline when navigating to a new page

1075. By Chris Coulson on 2015-05-15

Refactor ownership model of BrowserContext, and discard the OTR BrowserContext as soon as all incognito webviews using it have been deleted

1076. By Chris Coulson on 2015-05-15

Actually fix tst_OxideGlobal.qml

1077. By Chris Coulson on 2015-05-15

Don't create multiple WebContexts pointing at the same path in tst_UnloadHandlers.qml

1078. By Riccardo Padovani on 2015-05-15

Add LoadEvent.httpStatusCode property

1079. By Chris Coulson on 2015-05-15

Bump Chromium rev to 44.0.2398.0

1080. By Chris Coulson on 2015-05-15

Revert a couple of changes that shouldn't have landed

1081. By Chris Coulson on 2015-05-18

Initialize handle_ for all Proxy objects

1082. By Chris Coulson on 2015-05-19

Flush profile data when the application goes in to the background

1083. By Chris Coulson on 2015-05-19

Generate a synthetic Suspended state on the phone

1084. By Chris Coulson on 2015-05-19

Remove spurious printf

1085. By Chris Coulson on 2015-05-20

Bump Chromium rev to 44.0.2403.0

1086. By Chris Coulson on 2015-05-20

Bump Chromium rev to 44.0.2403.4

1087. By Chris Coulson on 2015-05-21

Add a client interface for WebView, and implement that in qt/. This is the start of an attempt to split functionality out of WebView in to smaller classes

[Alexandre Abreu (abreu-alexandre)]

The comments have been addressed,

>
> > The image we get from QImage and the one we pasted are slightly
> > different but overall is the same image. QImage does some "processing"
> > on the raw image content that slightly alters it and make it hard to
> > have an exact match.
> How is that even possible? We’re talking about an uncompressed, lossless PNG,
> right?
> And I don’t see where QImage is involved in test_paste(), only raw data is
> passed around as QByteArrays.
> By the way, can’t we make the test image data smaller? A 1×1 PNG would suffice
> for testing purposes.

There are conversion to account for the alpha channel RGBA -> ARGB updates,

> In ClipboardQt::WriteHTML(), what prevents us from implementing the resolution
> of relative links?

this is something that is actually win32 specific,

[lp:~abreu-alexandre/oxide/clipboard]

1088. By Ugo Riboni on 2015-05-22

Add WebView.findController API

[Olivier Tilloy (osomon)]

Is the license and copyright header in qt/core/browser/oxide_qt_clipboard.[h|cc] correct?

In qt/core/browser/oxide_qt_browser_platform_integration.h:
 - shouldn’t the override of GetClipboardOxideFactory() be annotated with 'override' instead of 'final' ?

In qt/core/browser/oxide_qt_clipboard.h:
 - is "friend class Clipboard;" needed?
 - does the 'override' keywoard makes sense for a destructor?

In qt/core/browser/oxide_qt_clipboard.cc:
 - ClipboardChangedListener being a QObject, it would be more consistent to use Q_DISABLE_COPY instead of DISALLOW_COPY_AND_ASSIGN
 - In ClipboardChangedListener’s class declaration, the alignment of the visibility keywords is inconsistent
 - In ClipboardChangedListener::OnClipboardDataChanged, can you add an indentation level for 'case' statements and their contents?
 - shouldn’t ClipboardQt::WriteWebSmartPaste() be marked NOTIMPLEMENTED ?
 - it seems the checks on the nullness of QGuiApplication::clipboard() are not necessary, we can safely assume it will never be null (other code throughout Qt makes this assumption already)

In qt/tests/qmltests/core/tst_Clipboard.html:
 - div with id "blabla" is unused, can it be removed?

In qt/tests/qmltests/core/tst_Clipboard.qml:
 - in expect_has_file(), [result = result == 'true'] is incomplete: if 'expected' is false and 'result' is anything but "false" (including the empty string), the function should return false
 - indentation should use 2 spaces, not 4
 - test_copy() takes an unused 'data' parameter, can it be removed?

In qt/tests/qmltests/oxide_qml_testing_plugin.cc:
 - Qt includes are not ordered alphabetically
 - the newline in the middle of the first call to setData in copyToClipboard() is not necessary

There are a few of my previous comments that haven’t been addressed/answered, copying them here for reference:

> We’re missing unit tests for (at least) HTML markup.

>> The image we get from QImage and the one we pasted are slightly
>> different but overall is the same image. QImage does some "processing"
>> on the raw image content that slightly alters it and make it hard to
>> have an exact match.
> How is that even possible? We’re talking about an uncompressed,
> lossless PNG, right?
> And I don’t see where QImage is involved in test_paste(), only raw data
> is passed around as QByteArrays.

> In ClipboardQt::ReadAvailableTypes():
> - why not push types directly to the passed vector, instead of using
> an temporary vector and swapping its contents afterwards?
> - shouldn’t contains_filenames be set accordingly if one of the
> formats is "chromium/filename" ?

> In ClipboardQt::ReadHTML():
> - do we really need to clear markup and src_url prior to setting
> their content?

review: Needs Fixing

[lp:~abreu-alexandre/oxide/clipboard]

1089. By Alexandre Abreu on 2015-05-25

Add clipboard support

1090. By Alexandre Abreu on 2015-05-25

Nits

1091. By Alexandre Abreu on 2015-05-25

update test

[Alexandre Abreu (abreu-alexandre)]

> Is the license and copyright header in
> qt/core/browser/oxide_qt_clipboard.[h|cc] correct?
>
> In qt/core/browser/oxide_qt_browser_platform_integration.h:
> - shouldn’t the override of GetClipboardOxideFactory() be annotated with
> 'override' instead of 'final' ?
>
> In qt/core/browser/oxide_qt_clipboard.h:
> - is "friend class Clipboard;" needed?
> - does the 'override' keywoard makes sense for a destructor?

yes,

> In qt/core/browser/oxide_qt_clipboard.cc:
> - ClipboardChangedListener being a QObject, it would be more consistent to
> use Q_DISABLE_COPY instead of DISALLOW_COPY_AND_ASSIGN
> - In ClipboardChangedListener’s class declaration, the alignment of the
> visibility keywords is inconsistent
> - In ClipboardChangedListener::OnClipboardDataChanged, can you add an
> indentation level for 'case' statements and their contents?
> - shouldn’t ClipboardQt::WriteWebSmartPaste() be marked NOTIMPLEMENTED ?

it not actually, this is a special tag (mostly like a shell 'touch') that touches
the clipboard w/ null data

> - it seems the checks on the nullness of QGuiApplication::clipboard() are not
> necessary, we can safely assume it will never be null (other code throughout
> Qt makes this assumption already)
>
> In qt/tests/qmltests/core/tst_Clipboard.html:
> - div with id "blabla" is unused, can it be removed?
>
> In qt/tests/qmltests/core/tst_Clipboard.qml:
> - in expect_has_file(), [result = result == 'true'] is incomplete: if
> 'expected' is false and 'result' is anything but "false" (including the empty
> string), the function should return false
> - indentation should use 2 spaces, not 4
> - test_copy() takes an unused 'data' parameter, can it be removed?
>
> In qt/tests/qmltests/oxide_qml_testing_plugin.cc:
> - Qt includes are not ordered alphabetically
> - the newline in the middle of the first call to setData in copyToClipboard()
> is not necessary

addressed all the above (unless otherwise noted)

> There are a few of my previous comments that haven’t been addressed/answered,
> copying them here for reference:
>
> > We’re missing unit tests for (at least) HTML markup.
>
> >> The image we get from QImage and the one we pasted are slightly
> >> different but overall is the same image. QImage does some "processing"
> >> on the raw image content that slightly alters it and make it hard to
> >> have an exact match.
> > How is that even possible? We’re talking about an uncompressed,
> > lossless PNG, right?
> > And I don’t see where QImage is involved in test_paste(), only raw data
> > is passed around as QByteArrays.

as I said in my previous comment, there is a conversion happening, from ARGB -> RGBA

> > In ClipboardQt::ReadAvailableTypes():
> > - why not push types directly to the passed vector, instead of using
> > an temporary vector and swapping its contents afterwards?

it is mostly an exception safety reflex, not being destructive of args, etc. but
it obviously does not apply here

> > - shouldn’t contains_filenames be set accordingly if one of the
> > formats is "chromium/filename" ?
> > In ClipboardQt::ReadHTML():
> > - do we really need to clear markup and src_url prior to setting
> > the...

[Olivier Tilloy (osomon)]

>>> The image we get from QImage and the one we pasted are slightly
>>> different but overall is the same image. QImage does some "processing"
>>> on the raw image content that slightly alters it and make it hard to
>>> have an exact match.
>> How is that even possible? We’re talking about an uncompressed,
>> lossless PNG, right?
>> And I don’t see where QImage is involved in test_paste(), only raw data
>> is passed around as QByteArrays.
> as I said in my previous comment, there is a conversion happening,
> from ARGB -> RGBA

Could you please update the comment to make it explicit what the issue is, then?
 « some "processing" on the raw image content that slightly alters it » is rather vague, ARGB -> RGBA conversion is much more precise.

Where does the 34 magic number come from (in the call to expect_content)?

[lp:~abreu-alexandre/oxide/clipboard]

1092. By Alexandre Abreu on 2015-05-25

updates

1093. By Alexandre Abreu on 2015-05-25

update cmment

[Alexandre Abreu (abreu-alexandre)]

> >>> The image we get from QImage and the one we pasted are slightly
> >>> different but overall is the same image. QImage does some "processing"
> >>> on the raw image content that slightly alters it and make it hard to
> >>> have an exact match.
> >> How is that even possible? We’re talking about an uncompressed,
> >> lossless PNG, right?
> >> And I don’t see where QImage is involved in test_paste(), only raw data
> >> is passed around as QByteArrays.
> > as I said in my previous comment, there is a conversion happening,
> > from ARGB -> RGBA
>
> Could you please update the comment to make it explicit what the issue is,
> then?
> « some "processing" on the raw image content that slightly alters it » is
> rather vague, ARGB -> RGBA conversion is much more precise.

> Where does the 34 magic number come from (in the call to expect_content)?

I updated the comment

[Olivier Tilloy (osomon)]

I don’t really like that magic number, we could probably write a cleaner test by setting the contents of the clipboard on an Image object, and comparing its dimensions and pixel content to the expected values.

Aside from that, this now looks good to me. I wouldn’t mind a quick sanity review from Chris to validate the architecture though.

review: Approve

[Chris Coulson (chrisccoulson)]

I haven't done a thorough review, but there is one comment inline I'd like to see fixed before merging (the use of CONTENT_EXPORT in a code compiled in to ui_base isn't correct).

A couple of other minor points, although these can be fixed up afterwards:

- I'd prefer ClipboardQt to just be Clipboard, given that it's inside of the oxide::qt namespace
- It would be better if BrowserPlatformIntegration returned the actual Clipboard implementation instead of the factory function. The factory implementation can be private to oxide_browser_main_parts.cc (eg, see CreateUIMessagePump).
- I'm not sure I fully understand what ui::ClipboardOxide is for. Given that BrowserMainParts always calls ui::SetClipboardOxideFactory, then ui::Clipboard::Create() will always return the result from the implementation of BrowserPlatformIntegration. If it's meant to be a fallback where no clipboard implementation is provided by the embedding layer, then it doesn't really work because ui::Clipboard::Create() null checks the wrong thing. And a more appropriate name in this case would probably be something like "NullClipboard".

Other than that, this should be ok to merge

review: Approve

[Chris Coulson (chrisccoulson)]

Actually, forget my 3rd point there. Of course, in the current implementation, ui::SetClipboardOxideFactory can set a null factory if one isn't provided

[lp:~abreu-alexandre/oxide/clipboard]

1094. By Alexandre Abreu on 2015-05-26

removed CONTENT_EXPORT

[Alexandre Abreu (abreu-alexandre)]

Updated to remove the CONTENT_EXPORT ... I'll address the other points later this week,

=== added file 'patches/add-clipboard-create-override-mechanism.patch'
--- patches/add-clipboard-create-override-mechanism.patch	1970-01-01 00:00:00 +0000
+++ patches/add-clipboard-create-override-mechanism.patch	2015-05-26 19:17:26 +0000
@@ -0,0 +1,15 @@
+diff --git a/ui/base/ui_base.gyp b/ui/base/ui_base.gyp
+index 29fac97..43427a7 100644
+--- a/ui/base/ui_base.gyp
++++ b/ui/base/ui_base.gyp
+@@ -58,8 +58,8 @@
+         'clipboard/clipboard.h',
+         'clipboard/clipboard_android.cc',
+         'clipboard/clipboard_android.h',
+-        'clipboard/clipboard_aura.cc',
+-        'clipboard/clipboard_aura.h',
++        '<(DEPTH)/../../../shared/port/ui_base/clipboard_oxide.cc',
++        '<(DEPTH)/../../../shared/port/ui_base/clipboard_oxide.h',
+         'clipboard/clipboard_aurax11.cc',
+         'clipboard/clipboard_aurax11.h',
+         'clipboard/clipboard_constants.cc',

=== modified file 'patches/series'
--- patches/series	2015-04-21 18:34:44 +0000
+++ patches/series	2015-05-26 19:17:26 +0000
@@ -30,3 +30,4 @@
 allow-render-widget-compositor-settings-override.patch
 pulse-audio-role.patch
 enable-accelerated-canvas-on-arale.patch
+add-clipboard-create-override-mechanism.patch
\ No newline at end of file

=== modified file 'qt/core/browser/oxide_qt_browser_platform_integration.cc'
--- qt/core/browser/oxide_qt_browser_platform_integration.cc	2015-05-19 18:02:42 +0000
+++ qt/core/browser/oxide_qt_browser_platform_integration.cc	2015-05-26 19:17:26 +0000
@@ -40,6 +40,7 @@
 #include "oxide_qt_browser_thread_q_event_dispatcher.h"
 #include "oxide_qt_location_provider.h"
 #include "oxide_qt_message_pump.h"
+#include "oxide_qt_clipboard.h"
 
 namespace oxide {
 namespace qt {
@@ -189,6 +190,10 @@
   QGuiApplication::instance()->removeEventFilter(this);
 }
 
+ui::ClipboardOxideFactory BrowserPlatformIntegration::GetClipboardOxideFactory() {
+  return ClipboardQt::DoCreate;
+}
+
 QThread* GetIOQThread() {
   return g_io_thread.Get();
 }

=== modified file 'qt/core/browser/oxide_qt_browser_platform_integration.h'
--- qt/core/browser/oxide_qt_browser_platform_integration.h	2015-05-19 18:02:42 +0000
+++ qt/core/browser/oxide_qt_browser_platform_integration.h	2015-05-26 19:17:26 +0000
@@ -58,6 +58,7 @@
   content::LocationProvider* CreateLocationProvider() override;
   ApplicationState GetApplicationState() override;
   std::string GetApplicationLocale() override;
+  ui::ClipboardOxideFactory GetClipboardOxideFactory() override;
 
   // QObject implementation
   bool eventFilter(QObject* watched, QEvent* event) override;

=== added file 'qt/core/browser/oxide_qt_clipboard.cc'
--- qt/core/browser/oxide_qt_clipboard.cc	1970-01-01 00:00:00 +0000
+++ qt/core/browser/oxide_qt_clipboard.cc	2015-05-26 19:17:26 +0000
@@ -0,0 +1,408 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 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_qt_clipboard.h"
+
+#include <list>
+#include <set>
+
+#include "base/basictypes.h"
+#include "base/files/file_path.h"
+#include "base/logging.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/singleton.h"
+#include "base/metrics/histogram.h"
+#include "base/stl_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkImageInfo.h"
+#include "ui/base/clipboard/custom_data_helper.h"
+#include "ui/events/platform/platform_event_dispatcher.h"
+#include "ui/events/platform/platform_event_observer.h"
+#include "ui/events/platform/platform_event_source.h"
+#include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/geometry/size.h"
+
+#include <QDebug>
+#include <QClipboard>
+#include <QGuiApplication>
+#include <QImage>
+#include <QMimeData>
+#include <QObject>
+#include <QString>
+
+
+#define GET_CLIPBOARD_DATA(c) \
+  c->mimeData( \
+       type == ui::CLIPBOARD_TYPE_COPY_PASTE ? \
+       QClipboard::Clipboard \
+       : QClipboard::Selection)
+
+class ClipboardChangedListener : public QObject {
+  Q_OBJECT
+  
+ public:
+  ClipboardChangedListener();
+  uint64 clipboard_sequence_number() const {
+    return clipboard_sequence_number_;
+  }
+  uint64 selection_sequence_number() const {
+    return selection_sequence_number_;
+  }
+ private Q_SLOTS:
+  void OnClipboardDataChanged(QClipboard::Mode mode);
+ private:
+  uint64 clipboard_sequence_number_;
+  uint64 selection_sequence_number_;
+
+  Q_DISABLE_COPY(ClipboardChangedListener);
+};
+
+ClipboardChangedListener::ClipboardChangedListener()
+  : clipboard_sequence_number_(0),
+    selection_sequence_number_(0) {
+  QObject::connect(
+      QGuiApplication::clipboard(),
+      SIGNAL(changed(QClipboard::Mode)),
+      this,
+      SLOT(OnClipboardDataChanged(QClipboard::Mode)));
+}
+
+void ClipboardChangedListener::OnClipboardDataChanged(
+      QClipboard::Mode mode) {
+  switch (mode) {
+    case QClipboard::Clipboard:
+      ++clipboard_sequence_number_;
+      break;
+    case QClipboard::Selection:
+      ++selection_sequence_number_;
+      break;
+    default:
+      break;
+  }
+}
+
+namespace oxide {
+
+namespace qt {
+
+namespace {
+
+const char kMimeTypeWebkitSmartPaste[] = "chromium/x-webkit-paste";
+
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// ClipboardAuraX11
+
+ClipboardQt::ClipboardQt()
+  : clipboard_changed_listener_(new ClipboardChangedListener()),
+    write_mime_data_acc_(new QMimeData()) {
+  DCHECK(CalledOnValidThread());
+}
+
+ui::Clipboard* ClipboardQt::DoCreate() {
+  return new ClipboardQt();
+}
+
+ClipboardQt::~ClipboardQt() {
+  DCHECK(CalledOnValidThread());
+}
+
+uint64 ClipboardQt::GetSequenceNumber(ui::ClipboardType type) const {
+  DCHECK(CalledOnValidThread());
+  return type == ui::CLIPBOARD_TYPE_COPY_PASTE
+    ? clipboard_changed_listener_->clipboard_sequence_number()
+    : clipboard_changed_listener_->selection_sequence_number();
+}
+
+bool ClipboardQt::IsFormatAvailable(const FormatType& format,
+                                    ui::ClipboardType type) const {
+  DCHECK(CalledOnValidThread());
+  DCHECK(IsSupportedClipboardType(type));
+
+  const QMimeData *data = GET_CLIPBOARD_DATA(QGuiApplication::clipboard());
+  if ( ! data) {
+    return false;
+  }
+
+  return data->hasFormat(format.ToString().c_str());
+}
+
+void ClipboardQt::Clear(ui::ClipboardType type) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(IsSupportedClipboardType(type));
+  QGuiApplication::clipboard()->clear();
+}
+
+void ClipboardQt::ReadAvailableTypes(ui::ClipboardType type,
+                                     std::vector<base::string16>* types,
+                                     bool* contains_filenames) const {
+  DCHECK(IsSupportedClipboardType(type));
+  DCHECK(CalledOnValidThread());
+  DCHECK(types != nullptr);
+  DCHECK(contains_filenames != nullptr);
+
+  const QMimeData *data = GET_CLIPBOARD_DATA(QGuiApplication::clipboard());
+  if ( ! data) {
+    return;
+  }
+
+  *contains_filenames = false;
+  Q_FOREACH (const QString& format, data->formats()) {
+    types->push_back(base::UTF8ToUTF16(format.toUtf8().data()));
+
+    if (format == GetFilenameFormatType().ToString().c_str()) {
+      *contains_filenames = true;
+    }
+  }
+}
+
+void ClipboardQt::ReadText(ui::ClipboardType type,
+                           base::string16* result) const {
+  DCHECK(IsSupportedClipboardType(type));
+  DCHECK(CalledOnValidThread());
+
+  const QMimeData *data = GET_CLIPBOARD_DATA(QGuiApplication::clipboard());
+  if ( ! data || ! data->hasText()) {
+    return;
+  }
+
+  *result = base::UTF8ToUTF16(data->text().toUtf8().data());
+}
+
+void ClipboardQt::ReadAsciiText(ui::ClipboardType type,
+                                std::string* result) const {
+  DCHECK(IsSupportedClipboardType(type));
+  DCHECK(CalledOnValidThread());
+
+  const QMimeData *data = GET_CLIPBOARD_DATA(QGuiApplication::clipboard());
+  if ( ! data || ! data->hasText()) {
+    return;
+  }
+
+  *result = data->text().toStdString().c_str();
+}
+
+void ClipboardQt::ReadHTML(ui::ClipboardType type,
+                           base::string16* markup,
+                           std::string* src_url,
+                           uint32* fragment_start,
+                           uint32* fragment_end) const {
+  DCHECK(IsSupportedClipboardType(type));
+  DCHECK(CalledOnValidThread());
+
+  const QMimeData *data = GET_CLIPBOARD_DATA(QGuiApplication::clipboard());
+  if ( ! data || ! data->hasHtml()) {
+    return;
+  }
+
+  *markup = base::UTF8ToUTF16(data->html().toStdString());
+  *fragment_start = 0;
+  DCHECK(markup->length() <= kuint32max);
+  *fragment_end = static_cast<uint32>(markup->length());
+}
+
+void ClipboardQt::ReadRTF(ui::ClipboardType type, std::string* result) const {
+  DCHECK(IsSupportedClipboardType(type));
+  DCHECK(CalledOnValidThread());
+
+  const QMimeData *data = GET_CLIPBOARD_DATA(QGuiApplication::clipboard());
+  if ( ! data || ! data->hasFormat(QString::fromLatin1(kMimeTypeRTF))) {
+    return;
+  }
+
+  *result = data->data(QString::fromLatin1(kMimeTypeRTF)).data();
+}
+
+SkBitmap ClipboardQt::ReadImage(ui::ClipboardType type) const {
+  DCHECK(IsSupportedClipboardType(type));
+  DCHECK(CalledOnValidThread());
+
+  const QMimeData *md = GET_CLIPBOARD_DATA(QGuiApplication::clipboard());
+  if ( ! md) {
+    return SkBitmap();
+  }
+
+  QImage image;
+  if (md->hasImage()) {
+    image = qvariant_cast<QImage>(md->imageData());
+    /**
+     * ReadImage() is called from Blink when 'clipboardData.getAsFile'
+     * is called with a forced explicit mime type of 'image/png'.
+     * 
+     * See third_party/WebKit/Source/core/clipboard/DataObjectItem.cpp
+     */
+  } else if (md->hasFormat(Clipboard::kMimeTypePNG)) {
+    image.loadFromData(md->data(Clipboard::kMimeTypePNG), "PNG");
+  } else {
+    return SkBitmap();
+  }
+
+  if (image.format() != QImage::Format_RGBA8888) {
+    image.convertToFormat(QImage::Format_RGBA8888);
+  }
+
+  SkBitmap bitmap;
+  bitmap.setInfo(
+      SkImageInfo::MakeN32(
+          image.width(),
+          image.height(),
+          kOpaque_SkAlphaType));
+  
+  bitmap.setPixels(const_cast<uchar*>(image.constBits()));
+
+  // Force a deep copy of the image data
+  SkBitmap copy;
+  bitmap.copyTo(&copy, kN32_SkColorType);
+  return copy;
+}
+
+void ClipboardQt::ReadCustomData(ui::ClipboardType type,
+                                 const base::string16& data_type,
+                                 base::string16* result) const {
+  DCHECK(CalledOnValidThread());
+  DCHECK(IsSupportedClipboardType(type));
+  
+  const QMimeData *data = GET_CLIPBOARD_DATA(QGuiApplication::clipboard());
+  QString mime_type = QString::fromStdString(base::UTF16ToUTF8(data_type));
+  if ( ! data || ! data->hasFormat(mime_type)) {
+    return;
+  }
+
+  ui::ReadCustomDataForType(
+      data->data(mime_type).constData(),
+      data->data(mime_type).size(),
+      data_type,
+      result);
+}
+
+void ClipboardQt::ReadBookmark(base::string16* title,
+                               std::string* url) const {
+  NOTIMPLEMENTED();
+}
+
+void ClipboardQt::ReadData(const FormatType& format,
+                           std::string* result) const {
+  DCHECK(CalledOnValidThread());
+
+  const QMimeData *data = QGuiApplication::clipboard()->mimeData(QClipboard::Clipboard);
+  if ( ! data) {
+    return;
+  }
+
+  *result = data->data(format.ToString().c_str()).data();
+}
+
+void ClipboardQt::WriteObjects(ui::ClipboardType type,
+                               const ObjectMap& objects) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(IsSupportedClipboardType(type));
+
+  if (! write_mime_data_acc_) {
+    write_mime_data_acc_.reset(new QMimeData());
+  }
+
+  // dispatch all objects and gather the resulting mime data
+  for (ObjectMap::const_iterator iter = objects.begin();
+       iter != objects.end();
+       ++iter) {
+    DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
+  }
+
+  QGuiApplication::clipboard()->setMimeData(
+      write_mime_data_acc_.release(),
+      type == ui::CLIPBOARD_TYPE_COPY_PASTE
+      ? QClipboard::Clipboard
+      : QClipboard::Selection);
+}
+
+void ClipboardQt::WriteText(const char* text_data, size_t text_len) {
+  write_mime_data_acc_->setText(QString::fromUtf8(text_data, text_len));
+}
+
+void ClipboardQt::WriteHTML(const char* markup_data,
+                            size_t markup_len,
+                            const char* url_data,
+                            size_t url_len) {
+  write_mime_data_acc_->setHtml(
+      QString::fromUtf8(markup_data, markup_len));
+}
+
+void ClipboardQt::WriteRTF(const char* rtf_data, size_t data_len) {
+  write_mime_data_acc_->setData(QString::fromLatin1(kMimeTypeRTF), QByteArray(rtf_data, data_len));
+}
+
+void ClipboardQt::WriteBookmark(const char* title_data,
+                                     size_t title_len,
+                                     const char* url_data,
+                                     size_t url_len) {
+  NOTIMPLEMENTED();
+}
+
+void ClipboardQt::WriteWebSmartPaste() {
+  write_mime_data_acc_->setData(
+      QString::fromLatin1(kMimeTypeWebkitSmartPaste),
+      QByteArray());
+}
+
+void ClipboardQt::WriteBitmap(const SkBitmap& bitmap) {
+  QImage image;
+  if (bitmap.info().colorType() != kN32_SkColorType) {
+    SkImageInfo info =
+      SkImageInfo::MakeN32(
+        bitmap.width(),
+        bitmap.height(),
+        bitmap.alphaType());
+
+    SkBitmap convertedBitmap;
+    if (!convertedBitmap.tryAllocPixels(info)) {
+      return;
+    }
+
+    bitmap.readPixels(
+        info,
+        convertedBitmap.getPixels(),
+        0, 0, 0);
+
+    image = QImage(reinterpret_cast<const uchar *>(convertedBitmap.getPixels()),
+        bitmap.width(),
+        bitmap.height(),
+        QImage::Format_RGBA8888);
+  } else {
+    image = QImage(reinterpret_cast<const uchar *>(bitmap.getPixels()),
+        bitmap.width(),
+        bitmap.height(),
+        QImage::Format_RGBA8888);
+  }
+
+  write_mime_data_acc_->setImageData(image.copy());
+}
+
+void ClipboardQt::WriteData(const FormatType& format,
+                                 const char* data_data,
+                                 size_t data_len) {
+  write_mime_data_acc_->setData(
+      QString::fromStdString(format.ToString()),
+      QByteArray(data_data, data_len));
+}
+
+} // namespace qt
+} // namespace oxide
+
+#include "oxide_qt_clipboard.moc"

=== added file 'qt/core/browser/oxide_qt_clipboard.h'
--- qt/core/browser/oxide_qt_clipboard.h	1970-01-01 00:00:00 +0000
+++ qt/core/browser/oxide_qt_clipboard.h	2015-05-26 19:17:26 +0000
@@ -0,0 +1,94 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 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_BROWSER_CLIPBOARD_QT_H_
+#define _OXIDE_QT_CORE_BROWSER_CLIPBOARD_QT_H_
+
+#include "ui/base/clipboard/clipboard.h"
+
+#include "base/memory/scoped_ptr.h"
+
+class QMimeData;
+class ClipboardChangedListener;
+
+namespace oxide {
+namespace qt {
+
+class ClipboardQt : public ui::Clipboard {
+ public:
+
+  static Clipboard* DoCreate();
+  
+ private:
+
+  ClipboardQt();
+  ~ClipboardQt() override;
+
+  // Clipboard overrides
+
+  uint64 GetSequenceNumber(ui::ClipboardType type) const override;
+  bool IsFormatAvailable(const FormatType& format,
+                         ui::ClipboardType type) const override;
+  void Clear(ui::ClipboardType type) override;
+  void ReadAvailableTypes(ui::ClipboardType type,
+                          std::vector<base::string16>* types,
+                          bool* contains_filenames) const override;
+  void ReadText(ui::ClipboardType type, base::string16* result) const override;
+  void ReadAsciiText(ui::ClipboardType type, std::string* result) const override;
+  void ReadHTML(ui::ClipboardType type,
+                base::string16* markup,
+                std::string* src_url,
+                uint32* fragment_start,
+                uint32* fragment_end) const override;
+  void ReadRTF(ui::ClipboardType type, std::string* result) const override;
+  SkBitmap ReadImage(ui::ClipboardType type) const override;
+  void ReadCustomData(ui::ClipboardType clipboard_type,
+                      const base::string16& type,
+                      base::string16* result) const override;
+  void ReadBookmark(base::string16* title, std::string* url) const override;
+  void ReadData(const FormatType& format, std::string* result) const override;
+  void WriteObjects(ui::ClipboardType type, const ui::Clipboard::ObjectMap& objects) override;
+  void WriteText(const char* text_data, size_t text_len) override;
+  void WriteHTML(const char* markup_data,
+                 size_t markup_len,
+                 const char* url_data,
+                 size_t url_len) override;
+  void WriteRTF(const char* rtf_data, size_t data_len) override;
+  void WriteBookmark(const char* title_data,
+                     size_t title_len,
+                     const char* url_data,
+                     size_t url_len) override;
+  void WriteWebSmartPaste() override;
+  void WriteBitmap(const SkBitmap& bitmap) override;
+  void WriteData(const FormatType& format,
+                 const char* data_data,
+                 size_t data_len) override;
+
+ private:
+
+  scoped_ptr<ClipboardChangedListener> clipboard_changed_listener_;
+  
+  // Used for accumulated mimedata
+  scoped_ptr<QMimeData> write_mime_data_acc_;
+  
+  DISALLOW_COPY_AND_ASSIGN(ClipboardQt);
+};
+
+}  // namespace qt
+}  // namespace oxide
+
+#endif  // _OXIDE_QT_CORE_BROWSER_CLIPBOARD_QT_H_

=== modified file 'qt/core/core.gyp'
--- qt/core/core.gyp	2015-05-19 10:08:59 +0000
+++ qt/core/core.gyp	2015-05-26 19:17:26 +0000
@@ -68,6 +68,8 @@
         'browser/oxide_qt_browser_startup.h',
         'browser/oxide_qt_browser_thread_q_event_dispatcher.cc',
         'browser/oxide_qt_browser_thread_q_event_dispatcher.h',
+        'browser/oxide_qt_clipboard.cc',
+        'browser/oxide_qt_clipboard.h',
         'browser/oxide_qt_file_picker.cc',
         'browser/oxide_qt_file_picker.h',
         'browser/oxide_qt_javascript_dialog.cc',
@@ -134,6 +136,11 @@
       ],
       'actions': [
         {
+          'action_name': 'oxide_qt_clipboard.moc',
+          'moc_input': 'browser/oxide_qt_clipboard.cc',
+          'includes': [ 'moc.gypi' ]
+        },
+        {
           'action_name': 'oxide_qt_location_provider.moc',
           'moc_input': 'browser/oxide_qt_location_provider.cc',
           'includes': [ 'moc.gypi' ]

=== added file 'qt/tests/qmltests/core/tst_Clipboard.html'
--- qt/tests/qmltests/core/tst_Clipboard.html	1970-01-01 00:00:00 +0000
+++ qt/tests/qmltests/core/tst_Clipboard.html	2015-05-26 19:17:26 +0000
@@ -0,0 +1,33 @@
+<html>
+<body>
+  <h1>Clipboard</h1>
+
+  <textarea id="content"></textarea>
+
+  <span id="mime_type"></span>
+  <span id="has_file"></span>
+
+  <script>
+
+    window.onload = function() {
+
+    document.addEventListener("paste", function(e) {
+      for (var i = 0; i < e.clipboardData.items.length; ++i) {
+        document.getElementById("mime_type").innerHTML = e.clipboardData.items[i].type;
+        var blob = e.clipboardData.items[i].getAsFile();
+        document.getElementById("has_file").innerHTML = (blob != null) ? "true" : "false";
+        if (blob) {
+          var reader = new FileReader();
+          reader.addEventListener("loadend", function(e) {
+              document.getElementById("content").value = reader.result.substr(String("data:image/png;base64,").length)
+          });
+          reader.readAsDataURL(blob);
+        }
+      }
+    }, true);
+
+    }
+  </script>
+  
+</body>
+</html>

=== added file 'qt/tests/qmltests/core/tst_Clipboard.qml'
--- qt/tests/qmltests/core/tst_Clipboard.qml	1970-01-01 00:00:00 +0000
+++ qt/tests/qmltests/core/tst_Clipboard.qml	2015-05-26 19:17:26 +0000
@@ -0,0 +1,129 @@
+import QtQuick 2.0
+import QtTest 1.0
+import com.canonical.Oxide 1.0
+import com.canonical.Oxide.Testing 1.0
+
+TestWebView {
+  id: webView
+
+  focus: true
+
+  width: 200
+  height: 200
+
+  function expect_content(expected, rangemax) {
+    var result = webView.getTestApi().evaluateCode(
+        "return document.querySelector('#content').value", true);
+      if (!rangemax) {
+        rangemax = -1
+      }
+      return String(result).substr(0, rangemax) === expected.substr(0, rangemax);
+    }
+
+  function expect_has_file(expected) {
+    var result = webView.getTestApi().evaluateCode(
+        "return document.querySelector('#has_file').innerHTML", true);
+    if (result == 'true') {
+      result = true
+    } else if (result == 'false') {
+      result = false
+    } else {
+      return false
+    }
+    return (result === expected);
+  }
+
+  function expect_mime_type(expected) {
+    var result = webView.getTestApi().evaluateCode(
+      "return document.querySelector('#mime_type').innerHTML", true);
+      return (result === expected);
+  }
+
+  function select_textarea_content() {
+    webView.getTestApi().evaluateCode(
+        "document.querySelector('#content').select()", true);
+  }
+
+  function set_content(content) {
+    webView.getTestApi().evaluateCode(
+        "document.querySelector('#content').value = '" + content + "'", true);
+  }
+
+  function get_image_data() {
+    return "iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVQIHQEOAPH/AAAAAAAAAAAAAAAAAAAADgABd6ch7AAAAABJRU5ErkJggg=="
+  }
+
+  TestCase {
+    id: testcase
+    name: "clipboard"
+
+    when: windowShown
+
+    function setup() {
+      OxideTestingUtils.clearClipboard();
+    }
+
+    function test_paste_data() {
+      return [
+          { content: "content", mimeType: "text/plain" },
+          { content: get_image_data(), mimeType: "image/png"},
+          { content: "<div><a href=\"#\">Test</a></div>", mimeType: "text/html"},
+        ];
+    }
+
+    function test_paste(data) {
+      var isImage = (data.mimeType.indexOf("image/") === 0)
+
+      OxideTestingUtils.copyToClipboard(data.mimeType, data.content);
+
+      webView.url = "http://testsuite/tst_Clipboard.html";
+
+      verify(webView.waitForLoadSucceeded(), "Timed out waiting for successful load");
+
+      if ( ! isImage) {
+        select_textarea_content();
+      }
+      keyPress("v", Qt.ControlModifier)
+
+      verify(webView.waitFor(function() { return expect_mime_type(data.mimeType); }));
+      verify(webView.waitFor(function() { return expect_has_file(isImage); }));
+
+      if (isImage) {
+        /**
+         The image we get from QImage and the one we pasted are slightly different
+         but overall is the same image. QImage does ARGB -> RGBA conversion
+         on the raw image content
+         that slightly alters it and make it hard to have an exact match.
+         
+         The '34' magic number in this case has been empirically determined as the
+         maximum amount of content that stays the same after the conversion in this
+         context.
+         */
+        verify(webView.waitFor(function() { return expect_content(data.content, 34); }));
+      } else {
+        verify(webView.waitFor(function() { return expect_content(data.content); }));
+      }
+    }
+
+    function test_copy() {
+      webView.url = "http://testsuite/tst_Clipboard.html";
+
+      verify(webView.waitForLoadSucceeded(), "Timed out waiting for successful load");
+
+      var data_content = "content"
+      set_content(data_content)
+
+      webView.waitFor(function() { return expect_content(data_content); });
+
+      select_textarea_content();
+
+      keyPress("c", Qt.ControlModifier)
+
+      verify(webView.waitFor(function() {
+        var current_content = OxideTestingUtils.getFromClipboard(
+            "text/plain");
+        return current_content === data_content
+      }));
+    }
+  }
+}

=== modified file 'qt/tests/qmltests/oxide_qml_testing_plugin.cc'
--- qt/tests/qmltests/oxide_qml_testing_plugin.cc	2015-05-06 17:53:22 +0000
+++ qt/tests/qmltests/oxide_qml_testing_plugin.cc	2015-05-26 19:17:26 +0000
@@ -19,8 +19,10 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <QClipboard>
 #include <QCoreApplication>
 #include <QDesktopServices>
+#include <QGuiApplication>
 #include <QLatin1String>
 #include <QList>
 #include <QQmlContext>
@@ -163,7 +165,7 @@
   }
 
   Q_INVOKABLE QVariant getAppProperty(const QString& property) {
-    QCoreApplication::instance()->property(property.toStdString().c_str());
+    return QCoreApplication::instance()->property(property.toStdString().c_str());
   }
 
   Q_INVOKABLE void setAppProperty(const QString& property, const QVariant& value) {
@@ -189,6 +191,28 @@
       }
     }
   }
+
+  Q_INVOKABLE void copyToClipboard(const QString& mimeType, const QString& data) {
+    QMimeData * mime_data = new QMimeData();
+    if (mimeType.startsWith("image/")) {
+      mime_data->setData(mimeType, QByteArray::fromBase64(data.toUtf8()));
+    } else {
+      mime_data->setData(mimeType, data.toUtf8());
+    }
+    QGuiApplication::clipboard()->setMimeData(mime_data);
+  }
+
+  Q_INVOKABLE QString getFromClipboard(const QString& mimeType) {
+    const QMimeData * mime_data = QGuiApplication::clipboard()->mimeData();
+    if (mime_data->hasFormat(mimeType)) {
+      return QString(mime_data->data(mimeType));
+    }
+    return QString();
+  }
+
+  Q_INVOKABLE void clearClipboard() {
+    QGuiApplication::clipboard()->clear();
+  }
 };
 
 QObject* UtilsFactory(QQmlEngine* engine, QJSEngine* script_engine) {

=== modified file 'shared/browser/oxide_browser_main_parts.cc'
--- shared/browser/oxide_browser_main_parts.cc	2015-05-26 13:25:16 +0000
+++ shared/browser/oxide_browser_main_parts.cc	2015-05-26 19:17:26 +0000
@@ -43,6 +43,7 @@
 #include "shared/port/content/common/gpu_service_shim_oxide.h"
 #include "shared/port/gfx/gfx_utils_oxide.h"
 #include "shared/port/gpu_config/gpu_info_collector_oxide_linux.h"
+#include "shared/port/ui_base/clipboard_oxide.h"
 
 #include "oxide_browser_context.h"
 #include "oxide_browser_platform_integration.h"
@@ -193,6 +194,9 @@
   content::SetWebContentsViewOxideFactory(WebContentsView::Create);
   content::SetPowerSaveBlockerOxideDelegateFactory(CreatePowerSaveBlocker);
 
+  ui::SetClipboardOxideFactory(
+      BrowserPlatformIntegration::GetInstance()->GetClipboardOxideFactory());
+
   gfx::InitializeOxideNativeDisplay(
       BrowserPlatformIntegration::GetInstance()->GetNativeDisplay());
 

=== modified file 'shared/browser/oxide_browser_platform_integration.cc'
--- shared/browser/oxide_browser_platform_integration.cc	2015-03-24 17:06:40 +0000
+++ shared/browser/oxide_browser_platform_integration.cc	2015-05-26 19:17:26 +0000
@@ -90,4 +90,9 @@
                     ApplicationStateChanged());
 }
 
+ui::ClipboardOxideFactory
+BrowserPlatformIntegration::GetClipboardOxideFactory() {
+  return nullptr;
+}
+
 } // namespace oxide

=== modified file 'shared/browser/oxide_browser_platform_integration.h'
--- shared/browser/oxide_browser_platform_integration.h	2015-05-19 18:02:42 +0000
+++ shared/browser/oxide_browser_platform_integration.h	2015-05-26 19:17:26 +0000
@@ -24,6 +24,9 @@
 #include "content/public/browser/browser_thread.h"
 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
 
+#include "shared/port/ui_base/clipboard_oxide.h"
+
+
 class GURL;
 
 namespace content {
@@ -80,6 +83,8 @@
   // the applications UI event loop
   virtual scoped_ptr<MessagePump> CreateUIMessagePump() = 0;
 
+  virtual ui::ClipboardOxideFactory GetClipboardOxideFactory();
+
   // Called on the specified browser thread
   virtual void BrowserThreadInit(content::BrowserThread::ID id);
   virtual void BrowserThreadCleanUp(content::BrowserThread::ID id);

=== added directory 'shared/port/ui_base'
=== added file 'shared/port/ui_base/clipboard_oxide.cc'
--- shared/port/ui_base/clipboard_oxide.cc	1970-01-01 00:00:00 +0000
+++ shared/port/ui_base/clipboard_oxide.cc	2015-05-26 19:17:26 +0000
@@ -0,0 +1,260 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 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 "clipboard_oxide.h"
+
+#include "base/basictypes.h"
+#include "ui/base/clipboard/custom_data_helper.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+
+namespace ui {
+
+namespace {
+
+const char kMimeTypeFilename[] = "chromium/filename";
+const char kMimeTypeBitmap[] = "image/bmp";
+const char kMimeTypePepperCustomData[] = "chromium/x-pepper-custom-data";
+const char kMimeTypeWebkitSmartPaste[] = "chromium/x-webkit-paste";
+
+ClipboardOxideFactory g_clipboard_factory;
+
+}  // namespace
+
+
+void SetClipboardOxideFactory(ClipboardOxideFactory factory) {
+  g_clipboard_factory = factory;
+}
+
+// Clipboard factory method.
+Clipboard* Clipboard::Create() {
+  if (g_clipboard_factory) {
+    return g_clipboard_factory();
+  }
+  return new ClipboardOxide;
+}
+
+  
+// Clipboard::FormatType implementation.
+Clipboard::FormatType::FormatType() {
+}
+
+Clipboard::FormatType::FormatType(const std::string& native_format)
+    : data_(native_format) {
+}
+
+Clipboard::FormatType::~FormatType() {
+}
+
+std::string Clipboard::FormatType::Serialize() const {
+  return data_;
+}
+
+// static
+Clipboard::FormatType Clipboard::FormatType::Deserialize(
+    const std::string& serialization) {
+  return FormatType(serialization);
+}
+
+bool Clipboard::FormatType::operator<(const FormatType& other) const {
+  return data_ < other.data_;
+}
+
+bool Clipboard::FormatType::Equals(const FormatType& other) const {
+  return data_ == other.data_;
+}
+
+// Various predefined FormatTypes.
+// static
+Clipboard::FormatType Clipboard::GetFormatType(
+    const std::string& format_string) {
+  return FormatType::Deserialize(format_string);
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetUrlFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeURIList));
+  return type;
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetUrlWFormatType() {
+  return GetUrlFormatType();
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetPlainTextFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeText));
+  return type;
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetPlainTextWFormatType() {
+  return GetPlainTextFormatType();
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetFilenameFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeFilename));
+  return type;
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetFilenameWFormatType() {
+  return Clipboard::GetFilenameFormatType();
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetHtmlFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeHTML));
+  return type;
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetRtfFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeRTF));
+  return type;
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetBitmapFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeBitmap));
+  return type;
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetWebKitSmartPasteFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeWebkitSmartPaste));
+  return type;
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetWebCustomDataFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeWebCustomData));
+  return type;
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypePepperCustomData));
+  return type;
+}
+
+ClipboardOxide::ClipboardOxide() {
+  DCHECK(CalledOnValidThread());
+}
+
+ClipboardOxide::~ClipboardOxide() {
+  DCHECK(CalledOnValidThread());
+}
+
+uint64 ClipboardOxide::GetSequenceNumber(ClipboardType type) const {
+  DCHECK(CalledOnValidThread());
+  return uint64();
+}
+
+bool ClipboardOxide::IsFormatAvailable(const FormatType& format,
+                                      ClipboardType type) const {
+  DCHECK(CalledOnValidThread());
+  return false;
+}
+
+void ClipboardOxide::Clear(ClipboardType type) {
+  DCHECK(CalledOnValidThread());
+}
+
+void ClipboardOxide::ReadAvailableTypes(ClipboardType type,
+                                       std::vector<base::string16>* types,
+                                       bool* contains_filenames) const {
+  DCHECK(CalledOnValidThread());
+}
+
+void ClipboardOxide::ReadText(ClipboardType type, base::string16* result) const {
+  DCHECK(CalledOnValidThread());
+}
+
+void ClipboardOxide::ReadAsciiText(ClipboardType type,
+                                  std::string* result) const {
+  DCHECK(CalledOnValidThread());
+}
+
+void ClipboardOxide::ReadHTML(ClipboardType type,
+                             base::string16* markup,
+                             std::string* src_url,
+                             uint32* fragment_start,
+                             uint32* fragment_end) const {
+  DCHECK(CalledOnValidThread());
+}
+
+void ClipboardOxide::ReadRTF(ClipboardType type, std::string* result) const {
+  DCHECK(CalledOnValidThread());
+}
+
+SkBitmap ClipboardOxide::ReadImage(ClipboardType type) const {
+  DCHECK(CalledOnValidThread());
+  return SkBitmap();
+}
+
+void ClipboardOxide::ReadCustomData(ClipboardType clipboard_type,
+                                   const base::string16& type,
+                                   base::string16* result) const {
+  DCHECK(CalledOnValidThread());
+}
+
+void ClipboardOxide::ReadBookmark(base::string16* title,
+                                 std::string* url) const {
+  DCHECK(CalledOnValidThread());
+}
+
+void ClipboardOxide::ReadData(const FormatType& format,
+                             std::string* result) const {
+  DCHECK(CalledOnValidThread());
+}
+
+void ClipboardOxide::WriteObjects(ClipboardType type, const ObjectMap& objects) {
+  DCHECK(CalledOnValidThread());
+}
+
+void ClipboardOxide::WriteText(const char* text_data, size_t text_len) {
+}
+
+void ClipboardOxide::WriteHTML(const char* markup_data,
+                              size_t markup_len,
+                              const char* url_data,
+                              size_t url_len) {
+}
+
+void ClipboardOxide::WriteRTF(const char* rtf_data, size_t data_len) {
+}
+
+void ClipboardOxide::WriteBookmark(const char* title_data,
+                                  size_t title_len,
+                                  const char* url_data,
+                                  size_t url_len) {
+}
+
+void ClipboardOxide::WriteWebSmartPaste() {
+}
+
+void ClipboardOxide::WriteBitmap(const SkBitmap& bitmap) {
+}
+
+void ClipboardOxide::WriteData(const FormatType& format,
+                              const char* data_data,
+                              size_t data_len) {
+}
+
+}  // namespace ui

=== added file 'shared/port/ui_base/clipboard_oxide.h'
--- shared/port/ui_base/clipboard_oxide.h	1970-01-01 00:00:00 +0000
+++ shared/port/ui_base/clipboard_oxide.h	2015-05-26 19:17:26 +0000
@@ -0,0 +1,80 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 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_SHARED_PORT_UI_CLIPBOARD_OXIDE_H_
+#define OXIDE_SHARED_PORT_UI_CLIPBOARD_OXIDE_H_
+
+#include "ui/base/ui_base_export.h"
+#include "ui/base/clipboard/clipboard.h"
+
+namespace ui {
+
+class ClipboardOxide : public Clipboard {
+ public:
+  ClipboardOxide();
+  virtual ~ClipboardOxide();
+
+  // Clipboard overrides:
+  uint64 GetSequenceNumber(ClipboardType type) const override;
+  bool IsFormatAvailable(const FormatType& format,
+                         ClipboardType type) const override;
+  void Clear(ClipboardType type) override;
+  void ReadAvailableTypes(ClipboardType type,
+                          std::vector<base::string16>* types,
+                          bool* contains_filenames) const override;
+  void ReadText(ClipboardType type, base::string16* result) const override;
+  void ReadAsciiText(ClipboardType type, std::string* result) const override;
+  void ReadHTML(ClipboardType type,
+                base::string16* markup,
+                std::string* src_url,
+                uint32* fragment_start,
+                uint32* fragment_end) const override;
+  void ReadRTF(ClipboardType type, std::string* result) const override;
+  SkBitmap ReadImage(ClipboardType type) const override;
+  void ReadCustomData(ClipboardType clipboard_type,
+                      const base::string16& type,
+                      base::string16* result) const override;
+  void ReadBookmark(base::string16* title, std::string* url) const override;
+  void ReadData(const FormatType& format, std::string* result) const override;
+  void WriteObjects(ClipboardType type, const ObjectMap& objects) override;
+  void WriteText(const char* text_data, size_t text_len) override;
+  void WriteHTML(const char* markup_data,
+                 size_t markup_len,
+                 const char* url_data,
+                 size_t url_len) override;
+  void WriteRTF(const char* rtf_data, size_t data_len) override;
+  void WriteBookmark(const char* title_data,
+                     size_t title_len,
+                     const char* url_data,
+                     size_t url_len) override;
+  void WriteWebSmartPaste() override;
+  void WriteBitmap(const SkBitmap& bitmap) override;
+  void WriteData(const FormatType& format,
+                 const char* data_data,
+                 size_t data_len) override;
+
+  DISALLOW_COPY_AND_ASSIGN(ClipboardOxide);
+};
+
+typedef Clipboard* (*ClipboardOxideFactory) ();
+
+UI_BASE_EXPORT void SetClipboardOxideFactory(
+    ClipboardOxideFactory factory);
+
+}
+
+#endif // OXIDE_SHARED_PORT_UI_CLIPBOARD_OXIDE_H_