Clear the clipboard closing Incognito window

ui/base/clipboard/clipboard.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 <iterator>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 74 matching lines @@
 
 // Mapping from threads to clipboard objects.
 typedef std::map<base::PlatformThreadId, Clipboard*> ClipboardMap;
 static base::LazyInstance<ClipboardMap> g_clipboard_map =
     LAZY_INSTANCE_INITIALIZER;
 
 // Mutex that controls access to |g_clipboard_map|.
 static base::LazyInstance<base::Lock>::Leaky
     g_clipboard_map_lock = LAZY_INSTANCE_INITIALIZER;
 
+const std::size_t kSourceTagSize = sizeof(Clipboard::SourceTag);
+
+union SourceTag2BinaryHelper {
+  Clipboard::SourceTag tag;
+  uint8 bytes[kSourceTagSize];
+};
+
 }  // namespace
 
 const char Clipboard::kMimeTypeText[] = "text/plain";
 const char Clipboard::kMimeTypeURIList[] = "text/uri-list";
 const char Clipboard::kMimeTypeDownloadURL[] = "downloadurl";
 const char Clipboard::kMimeTypeHTML[] = "text/html";
 const char Clipboard::kMimeTypeRTF[] = "text/rtf";
 const char Clipboard::kMimeTypePNG[] = "image/png";
 
 // static
+Clipboard::ObjectMapParam Clipboard::SourceTag2Binary(SourceTag tag) {
+  SourceTag2BinaryHelper helper;
+  helper.tag = tag;
+  std::vector<char> bytes(kSourceTagSize);
+  memcpy(&bytes[0], helper.bytes, kSourceTagSize);
+  return bytes;
+}
+
+// static
+Clipboard::SourceTag Clipboard::Binary2SourceTag(const std::string& binary) {
+  if (binary.size() != kSourceTagSize)
+    return SourceTag();
+  SourceTag2BinaryHelper helper;
+  memcpy(helper.bytes, binary.c_str(), kSourceTagSize);
+  return helper.tag;
+}
+
+// static
 void Clipboard::SetAllowedThreads(
     const std::vector<base::PlatformThreadId>& allowed_threads) {
   base::AutoLock lock(g_clipboard_map_lock.Get());
 
   g_allowed_threads.Get().clear();
   std::copy(allowed_threads.begin(), allowed_threads.end(),
             std::back_inserter(g_allowed_threads.Get()));
 }
 
 // static
@@ skipping 31 matching lines @@
 
   ClipboardMap* clipboard_map = g_clipboard_map.Pointer();
   base::PlatformThreadId id = base::PlatformThread::CurrentId();
   ClipboardMap::iterator it = clipboard_map->find(id);
   if (it != clipboard_map->end()) {
     delete it->second;
     clipboard_map->erase(it);
   }
 }
 
+void Clipboard::WriteObjects(Buffer buffer,
+                             const ObjectMap& objects,
+                             SourceTag tag) {
+  WriteObjectsImpl(buffer, objects, tag);
+  FOR_EACH_OBSERVER(ClipboardObserverForTesting,
+                    observer_list_,
+                    OnWriteObjects(buffer));
+}
+
 void Clipboard::DispatchObject(ObjectType type, const ObjectMapParams& params) {
   // All types apart from CBF_WEBKIT need at least 1 non-empty param.
   if (type != CBF_WEBKIT && (params.empty() || params[0].empty()))
     return;
   // Some other types need a non-empty 2nd param.
   if ((type == CBF_BOOKMARK || type == CBF_BITMAP ||
        type == CBF_SMBITMAP || type == CBF_DATA) &&
       (params.size() != 2 || params[1].empty()))
     return;
   switch (type) {
@@ skipping 92 matching lines @@
       // UI thread (see DispatchObject()).
       iter->second[0].clear();
       for (size_t i = 0; i < sizeof(SharedMemory*); ++i)
         iter->second[0].push_back(reinterpret_cast<char*>(&bitmap)[i]);
       has_shared_bitmap = true;
     }
   }
 }
 
 }  // namespace ui