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 101 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_INCOGNITO_MARKER, // Signifies that data came from Incognito mode.
   };
 
   // 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 10 matching lines @@
   //                            The filenames are encoded in platform-specific
   //                            encoding.
   // CBF_WEBKIT    none         empty vector
   // CBF_BITMAP    pixels       byte array
   //               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
+  // CBF_INCOGNITO_MARKER
+  //               data         byte array
   typedef std::vector<char> ObjectMapParam;
   typedef std::vector<ObjectMapParam> ObjectMapParams;
   typedef std::map<int /* ObjectType */, ObjectMapParams> ObjectMap;
 
   // 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,
   };
 
+  class ClipboardObserver {
+   public:
+    // Called at the end of Clipboard::WriteObjects()
+    virtual void OnWriteObjects(Buffer buffer) = 0;

[dcheng, 2013/01/31 22:25:56]

I feel a little uncertain about having a ClipboardObserver that isn't really a
clipboard observer (it only triggers in one very specific circumstance)

Would it be better to write a UI test util that detects when the clipboard
changes? Win and Linux both have support for receiving notifications when the
clipboard changes; Mac can be implemented by polling.

[battre, 2013/02/01 09:36:39]

I think the polling on Mac would be very awkward. In particular it would make
the tests slow and potentially flaky (polling is highly discouraged in testing
by Pawel). Also we don't need to do the polling unless we are in unit tests.

Given that we need this observer only for unit testing, my proposal would be the
following:

Rename ClipboardObserver to ClipboardObserverForTesting and add a comment
// This observer notices and reports only write operations though class
Clipboard.
// Modifications from other applications in the operating system are not
reported.

WDYT?

+   protected:
+    virtual ~ClipboardObserver() {}
+  };
+
+  void AddObserver(ClipboardObserver* obs) {
+    observer_list_.AddObserver(obs);
+  }
+
+  void RemoveObserver(ClipboardObserver* 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 86 matching lines @@
   static const FormatType& GetFilenameWFormatType();
   static const FormatType& GetWebKitSmartPasteFormatType();
   // Win: MS HTML Format, Other: Generic HTML format
   static const FormatType& GetHtmlFormatType();
   static const FormatType& GetRtfFormatType();
   static const FormatType& GetBitmapFormatType();
   // TODO(raymes): Unify web custom data and pepper custom data:
   // crbug.com/158399.
   static const FormatType& GetWebCustomDataFormatType();
   static const FormatType& GetPepperCustomDataFormatType();
+  static const FormatType& GetIncognitoMarkerFormatType();
 
   // Embeds a pointer to a SharedMemory object pointed to by |bitmap_handle|
   // belonging to |process| into a shared bitmap [CBF_SMBITMAP] slot in
   // |objects|.  The pointer is deleted by DispatchObjects().
   //
   // On non-Windows platforms, |process| is ignored.
   static void ReplaceSharedMemHandle(ObjectMap* objects,
                                      base::SharedMemoryHandle bitmap_handle,
                                      base::ProcessHandle process);
 #if defined(OS_WIN)
   // Firefox text/html
   static const FormatType& GetTextHtmlFormatType();
   static const FormatType& GetCFHDropFormatType();
   static const FormatType& GetFileDescriptorFormatType();
   static const FormatType& GetFileContentFormatZeroType();
 #endif
 
  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);
+
   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,
@@ skipping 55 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<ClipboardObserver> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(Clipboard);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_CLIPBOARD_CLIPBOARD_H_