Use XFixes to update the clipboard sequence number.

ui/base/clipboard/clipboard_gtk.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/base/clipboard/clipboard.h"
 
 #include <gtk/gtk.h>
+#include <X11/extensions/Xfixes.h>
+#include <X11/Xatom.h>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/file_path.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/singleton.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/base/gtk/gtk_signal.h"
+#include "ui/base/x/x11_util.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/gtk_util.h"
 #include "ui/gfx/size.h"
 
 namespace ui {
 
 namespace {
 
+class SelectionChangeObserver {
+ public:
+  static SelectionChangeObserver* GetInstance();
+
+  uint64 clipboard_sequence_number() const {
+    return clipboard_sequence_number_;
+  }
+  uint64 primary_sequence_number() const { return primary_sequence_number_; }
+
+ private:
+  friend struct DefaultSingletonTraits<SelectionChangeObserver>;
+
+  SelectionChangeObserver();
+  ~SelectionChangeObserver();
+
+  CHROMEG_CALLBACK_1(SelectionChangeObserver, GdkFilterReturn, OnXEvent,
+                     GdkXEvent*, GdkEvent*);
+
+  int event_base_;
+  Atom clipboard_atom_;
+  uint64 clipboard_sequence_number_;
+  uint64 primary_sequence_number_;
+
+  DISALLOW_COPY_AND_ASSIGN(SelectionChangeObserver);
+};
+
+SelectionChangeObserver::SelectionChangeObserver()
+    : event_base_(-1),
+      clipboard_atom_(None),
+      clipboard_sequence_number_(0),
+      primary_sequence_number_(0) {
+  int ignored;
+  if (XFixesQueryExtension(GetXDisplay(), &event_base_, &ignored)) {
+    clipboard_atom_ = XInternAtom(GetXDisplay(), "CLIPBOARD", false);
+    XFixesSelectSelectionInput(GetXDisplay(), GetX11RootWindow(),
+                               clipboard_atom_,
+                               XFixesSetSelectionOwnerNotifyMask |
+                               XFixesSelectionWindowDestroyNotifyMask |
+                               XFixesSelectionClientCloseNotifyMask);
+    // This seems to be semi-optional. For some reason, registering for any
+    // selection notify events seems to subscribe us to events for both the
+    // primary and the clipboard buffers. Register anyway just to be safe.
+    XFixesSelectSelectionInput(GetXDisplay(), GetX11RootWindow(),
+                               XA_PRIMARY,
+                               XFixesSetSelectionOwnerNotifyMask |
+                               XFixesSelectionWindowDestroyNotifyMask |
+                               XFixesSelectionClientCloseNotifyMask);
+    gdk_window_add_filter(NULL, &SelectionChangeObserver::OnXEventThunk, this);
+  }
+}
+
+SelectionChangeObserver::~SelectionChangeObserver() {
+}
+
+SelectionChangeObserver* SelectionChangeObserver::GetInstance() {
+  return Singleton<SelectionChangeObserver>::get();
+}
+
+GdkFilterReturn SelectionChangeObserver::OnXEvent(GdkXEvent* xevent,
+                                                  GdkEvent* event) {
+  XEvent* xev = static_cast<XEvent*>(xevent);
+
+  if (xev->type == event_base_ + XFixesSelectionNotify) {
+    XFixesSelectionNotifyEvent* ev =
+        reinterpret_cast<XFixesSelectionNotifyEvent*>(xev);
+    if (ev->selection == clipboard_atom_) {
+      clipboard_sequence_number_++;
+    } else if (ev->selection == XA_PRIMARY) {
+      primary_sequence_number_++;
+    } else {
+      DLOG(ERROR) << "Unexpected selection atom: " << ev->selection;
+    }
+  }
+  return GDK_FILTER_CONTINUE;
+}
+
 const char kMimeTypeBitmap[] = "image/bmp";
 const char kMimeTypeMozillaURL[] = "text/x-moz-url";
 const char kMimeTypeWebkitSmartPaste[] = "chromium/x-webkit-paste";
 
 std::string GdkAtomToString(const GdkAtom& atom) {
   gchar* name = gdk_atom_name(atom);
   std::string rv(name);
   g_free(name);
   return rv;
 }
@@ skipping 380 matching lines @@
 void Clipboard::ReadData(const std::string& format, std::string* result) {
   GtkSelectionData* data =
       gtk_clipboard_wait_for_contents(clipboard_, StringToGdkAtom(format));
   if (!data)
     return;
   result->assign(reinterpret_cast<char*>(data->data), data->length);
   gtk_selection_data_free(data);
 }
 
 uint64 Clipboard::GetSequenceNumber(Buffer buffer) {
-  // TODO(cdn): implement this. For now this interface will advertise
-  // that the Linux clipboard never changes. That's fine as long as we
-  // don't rely on this signal.
-  return 0;
+  if (buffer == BUFFER_STANDARD)
+    return SelectionChangeObserver::GetInstance()->clipboard_sequence_number();
+  else
+    return SelectionChangeObserver::GetInstance()->primary_sequence_number();
 }
 
 // static
 Clipboard::FormatType Clipboard::GetPlainTextFormatType() {
   return GdkAtomToString(GDK_TARGET_STRING);
 }
 
 // static
 Clipboard::FormatType Clipboard::GetPlainTextWFormatType() {
   return GetPlainTextFormatType();
@@ skipping 27 matching lines @@
       return clipboard_;
     case BUFFER_SELECTION:
       return primary_selection_;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 }  // namespace ui