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(Buffer buffer) const {
+  DCHECK(CalledOnValidThread());
+  DCHECK_EQ(BUFFER_STANDARD, buffer);
+  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