Clear the clipboard closing Incognito window

ui/base/clipboard/clipboard_chromeos.cc

 // 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.
 
 #include "ui/base/clipboard/clipboard.h"
 
 #include <list>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
@@ skipping 16 matching lines @@
 
 // Clipboard data format used by AuraClipboard.
 enum AuraClipboardFormat {
   TEXT      = 1 << 0,
   HTML      = 1 << 1,
   RTF       = 1 << 2,
   BOOKMARK  = 1 << 3,
   BITMAP    = 1 << 4,
   CUSTOM    = 1 << 5,
   WEB       = 1 << 6,
+  SOURCETAG = 1 << 7,
 };
 
 // ClipboardData contains data copied to the Clipboard for a variety of formats.
 // It mostly just provides APIs to cleanly access and manipulate this data.
 class ClipboardData {
  public:
   ClipboardData()
       : bitmap_data_(),
+        source_tag_(),
         web_smart_paste_(false),
         format_(0) {}
 
   virtual ~ClipboardData() {}
 
   // Bitmask of AuraClipboardFormat types.
   const int format() const { return format_; }
 
   const std::string& text() const { return text_; }
   void set_text(const std::string& text) {
@@ skipping 56 matching lines @@
     custom_data_format_ = data_format;
     format_ |= CUSTOM;
   }
 
   bool web_smart_paste() const { return web_smart_paste_; }
   void set_web_smart_paste(bool web_smart_paste) {
     web_smart_paste_ = web_smart_paste;
     format_ |= WEB;
   }
 
+  Clipboard::SourceTag source_tag() const { return source_tag_; }
+  void set_source_tag(Clipboard::SourceTag tag) {
+    source_tag_ = tag;
+    format_ |= SOURCETAG;
+  }
+
  private:
   // Plain text in UTF8 format.
   std::string text_;
 
   // HTML markup data in UTF8 format.
   std::string markup_data_;
   std::string url_;
 
   // RTF data.
   std::string rtf_data_;
 
   // Bookmark title in UTF8 format.
   std::string bookmark_title_;
   std::string bookmark_url_;
 
   // Filenames.
   std::vector<std::string> files_;
 
   // Bitmap images.
   scoped_ptr<uint8_t[]> bitmap_data_;
   gfx::Size bitmap_size_;
 
   // Data with custom format.
   std::string custom_data_format_;
   std::string custom_data_data_;
 
+  // SourceTag.
+  Clipboard::SourceTag source_tag_;
+
   // WebKit smart paste data.
   bool web_smart_paste_;
 
   int format_;
 
   DISALLOW_COPY_AND_ASSIGN(ClipboardData);
 };
 
 // Platform clipboard implementation for Aura. This handles things like format
 // conversion, versioning of clipboard items etc. The goal is to roughly provide
@@ skipping 132 matching lines @@
 
   void ReadData(const std::string& type, std::string* result) const {
     result->clear();
     const ClipboardData* data = GetData();
     if (!HasFormat(CUSTOM) || type != data->custom_data_format())
       return;
 
     *result = data->custom_data_data();
   }
 
+  Clipboard::SourceTag ReadSourceTag() const {
+    if (!HasFormat(SOURCETAG))
+      return Clipboard::SourceTag();
+    const ClipboardData* data = GetData();
+    return data->source_tag();
+  }
+
   // Writes |data| to the top of the clipboard stack.
   void WriteData(ClipboardData* data) {
     DCHECK(data);
     AddToListEnsuringSize(data);
   }
 
  private:
   // True if the data on top of the clipboard stack has format |format|.
   bool HasFormat(AuraClipboardFormat format) const {
     const ClipboardData* data = GetData();
@@ skipping 83 matching lines @@
     data->SetBitmapData(pixel_data, size_data);
   }
 
   static void WriteData(const std::string& format,
                         const char* data_data,
                         size_t data_len) {
     ClipboardData* data = GetCurrentData();
     data->SetCustomData(format, std::string(data_data, data_len));
   }
 
+  static void WriteSourceTag(Clipboard::SourceTag tag) {
+    ClipboardData* data = GetCurrentData();
+    data->set_source_tag(tag);
+  }
+
  private:
   static ClipboardData* GetCurrentData() {
     if (!current_data_)
       current_data_ = new ClipboardData;
     return current_data_;
   }
 
   static ClipboardData* current_data_;
 };
 
@@ skipping 29 matching lines @@
   DCHECK(CalledOnValidThread());
   // Make sure clipboard is created.
   GetClipboard();
 }
 
 Clipboard::~Clipboard() {
   DCHECK(CalledOnValidThread());
   DeleteClipboard();
 }
 
-void Clipboard::WriteObjects(Buffer buffer, const ObjectMap& objects) {
+void Clipboard::WriteObjectsImpl(Buffer buffer,
+                                 const ObjectMap& objects,
+                                 SourceTag tag) {
   DCHECK(CalledOnValidThread());
   DCHECK(IsValidBuffer(buffer));
   for (ObjectMap::const_iterator iter = objects.begin();
        iter != objects.end(); ++iter) {
     DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
   }
+  WriteSourceTag(tag);
   ClipboardDataBuilder::CommitToClipboard();
 }
 
 bool Clipboard::IsFormatAvailable(const FormatType& format,
                                   Buffer buffer) const {
   DCHECK(CalledOnValidThread());
   DCHECK(IsValidBuffer(buffer));
   AuraClipboard* clipboard = GetClipboard();
   if (GetPlainTextFormatType().Equals(format) ||
       GetUrlFormatType().Equals(format))
@@ skipping 86 matching lines @@
 void Clipboard::ReadBookmark(string16* title, std::string* url) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadBookmark(title, url);
 }
 
 void Clipboard::ReadData(const FormatType& format, std::string* result) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadData(format.ToString(), result);
 }
 
+Clipboard::SourceTag Clipboard::ReadSourceTag() const {

[dcheng, 2013/02/06 22:31:40]

Can we just use ReadData() and WriteData() like the other clipboard
implementations? If we did that, could we move the implemention into
clipboard.cc directly and make minimal changes to the rest of the clipboard_*.cc
files?

That way, we can also move the SourceTag2Binary helpers into clipboard.cc as
well.

[vasilii, 2013/02/07 17:30:05]

Unfortunately no. ClipboardData has an explicit member for each supported type.
If I use WriteData() it can overwrite user's custom data.
SourceTag2Binary helpers are already in clipboard.cc.

[dcheng, 2013/02/08 05:42:19]

... yikes. That's a bug. This is fine for now, but mind filing a cleanup bug for
this? You can assign it to me.

(As for the helpers, I meant moving them into an unnamed namespace into
clipboard.cc)

+  DCHECK(CalledOnValidThread());
+  return GetClipboard()->ReadSourceTag();
+}
+
 uint64 Clipboard::GetSequenceNumber(Buffer buffer) {
   DCHECK(CalledOnValidThread());
   return GetClipboard()->GetNumClipboardEntries();
 }
 
 void Clipboard::WriteText(const char* text_data, size_t text_len) {
   ClipboardDataBuilder::WriteText(text_data, text_len);
 }
 
 void Clipboard::WriteHTML(const char* markup_data,
@@ skipping 21 matching lines @@
 void Clipboard::WriteBitmap(const char* pixel_data, const char* size_data) {
   ClipboardDataBuilder::WriteBitmap(pixel_data, size_data);
 }
 
 void Clipboard::WriteData(const FormatType& format,
                           const char* data_data,
                           size_t data_len) {
   ClipboardDataBuilder::WriteData(format.ToString(), data_data, data_len);
 }
 
+void Clipboard::WriteSourceTag(SourceTag tag) {
+  if (tag != SourceTag())
+    ClipboardDataBuilder::WriteSourceTag(tag);
+}
+
 // 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;
@@ skipping 56 matching lines @@
   return type;
 }
 
 // static
 const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypePepperCustomData));
   return type;
 }
 
 }  // namespace ui