Clear the clipboard closing Incognito window

ui/base/clipboard/clipboard.h

 // Copyright (c) 2012 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.
 
 #ifndef UI_BASE_CLIPBOARD_CLIPBOARD_H_
 #define UI_BASE_CLIPBOARD_CLIPBOARD_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
+#include "base/observer_list.h"
 #include "base/process.h"
 #include "base/shared_memory.h"
 #include "base/string16.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/platform_thread.h"
 #include "ui/base/ui_export.h"
 
 #if defined(TOOLKIT_GTK)
 #include <gdk/gdk.h>
 #endif
@@ skipping 104 matching lines @@
   enum ObjectType {
     CBF_TEXT,
     CBF_HTML,
     CBF_RTF,
     CBF_BOOKMARK,
     CBF_FILES,
     CBF_WEBKIT,
     CBF_BITMAP,
     CBF_SMBITMAP,  // Bitmap from shared memory.
     CBF_DATA,  // Arbitrary block of bytes.
+    CBF_SOURCE_TAG, // Signifies the source of data.
   };
 
   // ObjectMap is a map from ObjectType to associated data.
   // The data is organized differently for each ObjectType. The following
   // table summarizes what kind of data is stored for each key.
   // * indicates an optional argument.
   //
   // Key           Arguments    Type
   // -------------------------------------
   // CBF_TEXT      text         char array
@@ skipping 14 matching lines @@
   //               size         gfx::Size struct
   // CBF_SMBITMAP  shared_mem   A pointer to an unmapped base::SharedMemory
   //                            object containing the bitmap data.
   //               size         gfx::Size struct
   // CBF_DATA      format       char array
   //               data         byte array
   typedef std::vector<char> ObjectMapParam;
   typedef std::vector<ObjectMapParam> ObjectMapParams;
   typedef std::map<int /* ObjectType */, ObjectMapParams> ObjectMap;
 
+  // WriteObject() caller can use the SourceTag that will be stored in the
+  // clipboard. NULL value means "no tag".
+  typedef void* SourceTag;
+  static ObjectMapParam SourceTag2Binary(SourceTag tag);
+  static SourceTag Binary2SourceTag(const std::string& serialization);
+
   // Buffer designates which clipboard the action should be applied to.
   // Only platforms that use the X Window System support the selection
   // buffer.
   enum Buffer {
     BUFFER_STANDARD,
     BUFFER_SELECTION,
   };
 
+  // This observer does track only calls to Clipboard::WriteObjects.
+  // Don't use it for notification about changed OS clipboard.
+  class ClipboardObserverForTesting {
+   public:
+    // Called at the end of Clipboard::WriteObjects().
+    virtual void OnWriteObjects(Buffer buffer) = 0;
+   protected:
+    virtual ~ClipboardObserverForTesting() {}
+  };
+
+  void AddObserver(ClipboardObserverForTesting* obs) {
+    observer_list_.AddObserver(obs);
+  }
+
+  void RemoveObserver(ClipboardObserverForTesting* obs) {
+    observer_list_.RemoveObserver(obs);
+  }
+
   static bool IsValidBuffer(int32 buffer) {
     switch (buffer) {
       case BUFFER_STANDARD:
         return true;
 #if defined(USE_X11) && !defined(OS_CHROMEOS)
       case BUFFER_SELECTION:
         return true;
 #endif
     }
     return false;
@@ skipping 17 matching lines @@
 
   // Destroys the clipboard for the current thread. Usually, this will clean up
   // all clipboards, except on Windows. (Previous code leaks the IO thread
   // clipboard, so it shouldn't be a problem.)
   static void DestroyClipboardForCurrentThread();
 
   // Write a bunch of objects to the system clipboard. Copies are made of the
   // contents of |objects|. On Windows they are copied to the system clipboard.
   // On linux they are copied into a structure owned by the Clipboard object and
   // kept until the system clipboard is set again.
-  void WriteObjects(Buffer buffer, const ObjectMap& objects);
+  // SourceTag is optional value to be stored in the clipboard, NULL won't be
+  // stored.
+  void WriteObjects(Buffer buffer, const ObjectMap& objects, SourceTag tag);
 
   // Returns a sequence number which uniquely identifies clipboard state.
   // This can be used to version the data on the clipboard and determine
   // whether it has changed.
   uint64 GetSequenceNumber(Buffer buffer);
 
   // Tests whether the clipboard contains a certain format
   bool IsFormatAvailable(const FormatType& format, Buffer buffer) const;
 
   // Clear the clipboard data.
@@ skipping 26 matching lines @@
                       const string16& type,
                       string16* result) const;
 
   // Reads a bookmark from the clipboard, if available.
   void ReadBookmark(string16* title, std::string* url) const;
 
   // Reads raw data from the clipboard with the given format type. Stores result
   // as a byte vector.
   void ReadData(const FormatType& format, std::string* result) const;
 
+  // Reads Source tag from the clipboard, if available.
+  SourceTag ReadSourceTag() const;
+
   // Gets the FormatType corresponding to an arbitrary format string,
   // registering it with the system if needed. Due to Windows/Linux
   // limitiations, |format_string| must never be controlled by the user.
   static FormatType GetFormatType(const std::string& format_string);
 
   // Get format identifiers for various types.
   static const FormatType& GetUrlFormatType();
   static const FormatType& GetUrlWFormatType();
   static const FormatType& GetMozUrlFormatType();
   static const FormatType& GetPlainTextFormatType();
@@ skipping 29 matching lines @@
  private:
   FRIEND_TEST_ALL_PREFIXES(ClipboardTest, SharedBitmapTest);
   FRIEND_TEST_ALL_PREFIXES(ClipboardTest, EmptyHTMLTest);
   friend class ClipboardTest;
 
   Clipboard();
   ~Clipboard();
 
   void DispatchObject(ObjectType type, const ObjectMapParams& params);
 
+  void WriteObjectsImpl(Buffer buffer, const ObjectMap& objects, SourceTag tag);
+
   void WriteText(const char* text_data, size_t text_len);
 
   void WriteHTML(const char* markup_data,
                  size_t markup_len,
                  const char* url_data,
                  size_t url_len);
 
   void WriteRTF(const char* rtf_data, size_t data_len);
 
   void WriteBookmark(const char* title_data,
                      size_t title_len,
                      const char* url_data,
                      size_t url_len);
 
   void WriteWebSmartPaste();
 
   void WriteBitmap(const char* pixel_data, const char* size_data);
 
   void WriteData(const FormatType& format,
                  const char* data_data,
                  size_t data_len);
+
+  void WriteSourceTag(SourceTag tag);
+
+  static const FormatType& GetSourceTagFormatType();
 #if defined(OS_WIN)
   void WriteBitmapFromHandle(HBITMAP source_hbitmap,
                              const gfx::Size& size);
 
   // Safely write to system clipboard. Free |handle| on failure.
   void WriteToClipboard(unsigned int format, HANDLE handle);
 
   static void ParseBookmarkClipboardFormat(const string16& bookmark,
                                            string16* title,
                                            std::string* url);
@@ skipping 34 matching lines @@
   TargetMap* clipboard_data_;
   GtkClipboard* clipboard_;
   GtkClipboard* primary_selection_;
 #elif defined(USE_AURA) && defined(USE_X11) && !defined(OS_CHROMEOS)
  private:
   // We keep our implementation details private because otherwise we bring in
   // the X11 headers and break chrome compile.
   class AuraX11Details;
   scoped_ptr<AuraX11Details> aurax11_details_;
 #endif
+  ObserverList<ClipboardObserverForTesting> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(Clipboard);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_CLIPBOARD_CLIPBOARD_H_