mac: Fix bookmark drag and drop.

components/bookmarks/browser/bookmark_pasteboard_helper_mac.mm

 // Copyright 2014 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 "components/bookmarks/browser/bookmark_pasteboard_helper_mac.h"
 
 #import <Cocoa/Cocoa.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 162 matching lines @@
           idNum, kChromiumBookmarkId,
           metaInfoDictionary, kChromiumBookmarkMetaInfo,
           nil];
       [plist addObject:object];
     }
   }
   return plist;
 }
 
 void WriteBookmarkDictionaryListPboardType(
-    NSPasteboard* pb,
+    NSPasteboardItem* item,
     const std::vector<BookmarkNodeData::Element>& elements) {
   NSArray* plist = GetPlistForBookmarkList(elements);
   NSString* uti = ui::ClipboardUtil::UTIForPasteboardType(
       kBookmarkDictionaryListPboardType);
-  [pb addTypes:@[ uti ] owner:nil];
-  [pb setPropertyList:plist forType:uti];
+  [item setPropertyList:plist forType:uti];
 }
 
 void FillFlattenedArraysForBookmarks(
     const std::vector<BookmarkNodeData::Element>& elements,
     NSMutableArray* url_titles,
     NSMutableArray* urls,
     NSMutableArray* toplevel_string_data) {
   for (const BookmarkNodeData::Element& element : elements) {
     NSString* title = base::SysUTF16ToNSString(element.title);
     if (element.is_url) {
       NSString* url = base::SysUTF8ToNSString(element.url.spec());
       [url_titles addObject:title];
       [urls addObject:url];
       if (toplevel_string_data)
         [toplevel_string_data addObject:url];
     } else {
       if (toplevel_string_data)
         [toplevel_string_data addObject:title];
       FillFlattenedArraysForBookmarks(element.children, url_titles, urls, nil);
     }
   }
 }
 
-void WriteSimplifiedBookmarkTypes(
-    NSPasteboard* pb,
+base::scoped_nsobject<NSPasteboardItem> WriteSimplifiedBookmarkTypes(
     const std::vector<BookmarkNodeData::Element>& elements) {
   NSMutableArray* url_titles = [NSMutableArray array];
   NSMutableArray* urls = [NSMutableArray array];
   NSMutableArray* toplevel_string_data = [NSMutableArray array];
   FillFlattenedArraysForBookmarks(
       elements, url_titles, urls, toplevel_string_data);
 
+  base::scoped_nsobject<NSPasteboardItem> item;
   if ([urls count] > 0) {
-    base::scoped_nsobject<NSPasteboardItem> item;
     if ([urls count] == 1) {
       item = ui::ClipboardUtil::PasteboardItemFromUrl([urls firstObject],
                                                       [url_titles firstObject]);
     } else {
       item = ui::ClipboardUtil::PasteboardItemFromUrls(urls, url_titles);
     }
-
-    ui::ClipboardUtil::AddDataToPasteboard(pb, item);
   }
 
-  // Write NSStringPboardType.
-  [pb addTypes:@[ NSStringPboardType ] owner:nil];
-  [pb setString:[toplevel_string_data componentsJoinedByString:@"\n"]
-        forType:NSStringPboardType];
+  if (!item) {
+    item = [[NSPasteboardItem alloc] init];
+  }
+
+  [item setString:[toplevel_string_data componentsJoinedByString:@"\n"]
+          forType:NSPasteboardTypeString];
+  return item;
 }
 
 NSPasteboard* PasteboardFromType(ui::ClipboardType type) {
   NSString* type_string = nil;
   switch (type) {
     case ui::CLIPBOARD_TYPE_COPY_PASTE:
       type_string = NSGeneralPboard;
       break;
     case ui::CLIPBOARD_TYPE_DRAG:
       type_string = NSDragPboard;
       break;
     case ui::CLIPBOARD_TYPE_SELECTION:
       NOTREACHED();
       break;
   }
 
   return [NSPasteboard pasteboardWithName:type_string];
 }
 
 }  // namespace
 
+NSPasteboardItem* PasteboardItemFromBookmarks(
+    const std::vector<BookmarkNodeData::Element>& elements,
+    const base::FilePath& profile_path) {
+  base::scoped_nsobject<NSPasteboardItem> item =
+      WriteSimplifiedBookmarkTypes(elements);
+
+  WriteBookmarkDictionaryListPboardType(item, elements);
+
+  NSString* uti =
+      ui::ClipboardUtil::UTIForPasteboardType(kChromiumProfilePathPboardType);
+  [item setString:base::SysUTF8ToNSString(profile_path.value()) forType:uti];
+  return [[item retain] autorelease];
+}
+
 void WriteBookmarksToPasteboard(
     ui::ClipboardType type,
     const std::vector<BookmarkNodeData::Element>& elements,
     const base::FilePath& profile_path) {
   if (elements.empty())
     return;
 
+  NSPasteboardItem* item = PasteboardItemFromBookmarks(elements, profile_path);
   NSPasteboard* pb = PasteboardFromType(type);
-
-  NSString* uti =
-      ui::ClipboardUtil::UTIForPasteboardType(kChromiumProfilePathPboardType);
-  [pb declareTypes:@[ uti ] owner:nil];
-  [pb setString:base::SysUTF8ToNSString(profile_path.value()) forType:uti];
-  WriteBookmarkDictionaryListPboardType(pb, elements);
-  WriteSimplifiedBookmarkTypes(pb, elements);
+  [pb clearContents];
+  [pb writeObjects:@[ item ]];
 }
 
 bool ReadBookmarksFromPasteboard(
     ui::ClipboardType type,
     std::vector<BookmarkNodeData::Element>& elements,
     base::FilePath* profile_path) {
   NSPasteboard* pb = PasteboardFromType(type);
 
   elements.clear();
   NSString* uti =
       ui::ClipboardUtil::UTIForPasteboardType(kChromiumProfilePathPboardType);
   NSString* profile = [pb stringForType:uti];
   *profile_path = base::FilePath(base::SysNSStringToUTF8(profile));
   return ReadBookmarkDictionaryListPboardType(pb, elements) ||
          ReadWebURLsWithTitlesPboardType(pb, elements);
 }
 
 bool PasteboardContainsBookmarks(ui::ClipboardType type) {
   NSPasteboard* pb = PasteboardFromType(type);
 
   NSArray* availableTypes = @[
     ui::ClipboardUtil::UTIForWebURLsAndTitles(),
     ui::ClipboardUtil::UTIForPasteboardType(kBookmarkDictionaryListPboardType)
   ];
   return [pb availableTypeFromArray:availableTypes] != nil;
 }
 
 }  // namespace bookmarks