Revert of Update BookmarkBarController to use non-deprecated dragging APIs.

chrome/browser/ui/cocoa/bookmarks/bookmark_button.mm

 // 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.
 
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_button.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/mac/foundation_util.h"
 #import "base/mac/scoped_nsobject.h"
-#include "base/mac/sdk_forward_declarations.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_folder_window.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_button_cell.h"
-#import "chrome/browser/ui/cocoa/bookmarks/bookmark_folder_target.h"
 #import "chrome/browser/ui/cocoa/browser_window_controller.h"
 #import "chrome/browser/ui/cocoa/view_id_util.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "content/public/browser/user_metrics.h"
 #include "ui/base/cocoa/cocoa_base_utils.h"
 #import "ui/base/cocoa/nsview_additions.h"
 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
 
 using base::UserMetricsAction;
 using bookmarks::BookmarkNode;
 
 // The opacity of the bookmark button drag image.
 static const CGFloat kDragImageOpacity = 0.7;
 
 namespace {
 // We need a class variable to track the current dragged button to enable
 // proper live animated dragging behavior, and can't do it in the
 // delegate/controller since you can drag a button from one domain to the
 // other (from a "folder" menu, to the main bar, or vice versa).
 BookmarkButton* gDraggedButton = nil; // Weak
 };
 
-@interface BookmarkButton() <NSPasteboardItemDataProvider>
-
-// NSPasteboardItemDataProvider:
-- (void)pasteboard:(NSPasteboard*)sender
-                  item:(NSPasteboardItem*)item
-    provideDataForType:(NSString*)type;
-
-// NSDraggingSource:
-- (void)draggingSession:(NSDraggingSession*)session
-           endedAtPoint:(NSPoint)aPoint
-              operation:(NSDragOperation)operation;
-- (NSDragOperation)draggingSession:(NSDraggingSession*)session
-    sourceOperationMaskForDraggingContext:(NSDraggingContext)context;
+@interface BookmarkButton(Private)
 
 // Make a drag image for the button.
 - (NSImage*)dragImage;
 
 - (void)installCustomTrackingArea;
 
 @end  // @interface BookmarkButton(Private)
 
+
 @implementation BookmarkButton
 
 @synthesize delegate = delegate_;
 @synthesize acceptsTrackIn = acceptsTrackIn_;
 
 - (id)initWithFrame:(NSRect)frameRect {
   // BookmarkButton's ViewID may be changed to VIEW_ID_OTHER_BOOKMARKS in
   // BookmarkBarController, so we can't just override -viewID method to return
   // it.
   if ((self = [super initWithFrame:frameRect])) {
@@ skipping 112 matching lines @@
   if ([self isFolder]) {
     // Close the folder's drop-down menu if it's visible.
     [[self target] closeBookmarkFolder:self];
   }
 
   // At the moment, moving bookmarks causes their buttons (like me!)
   // to be destroyed and rebuilt.  Make sure we don't go away while on
   // the stack.
   [self retain];
 
+  // Ask our delegate to fill the pasteboard for us.
+  NSPasteboard* pboard = [NSPasteboard pasteboardWithName:NSDragPboard];
+  [[self delegate] fillPasteboard:pboard forDragOfButton:self];
+
   // Lock bar visibility, forcing the overlay to stay visible if we are in
   // fullscreen mode.
   if ([[self delegate] dragShouldLockBarVisibility]) {
     DCHECK(!visibilityDelegate_);
     NSWindow* window = [[self delegate] browserWindow];
     visibilityDelegate_ =
         [BrowserWindowController browserWindowControllerForWindow:window];
     [visibilityDelegate_ lockBarVisibilityForOwner:self
                                      withAnimation:NO
                                              delay:NO];
   }
   const BookmarkNode* node = [self bookmarkNode];
   const BookmarkNode* parent = node ? node->parent() : NULL;
   if (parent && parent->type() == BookmarkNode::FOLDER) {
     content::RecordAction(UserMetricsAction("BookmarkBarFolder_DragStart"));
   } else {
     content::RecordAction(UserMetricsAction("BookmarkBar_DragStart"));
   }
 
   dragMouseOffset_ = [self convertPoint:[event locationInWindow] fromView:nil];
   dragPending_ = YES;
   gDraggedButton = self;
 
+  CGFloat yAt = [self bounds].size.height;
+  NSSize dragOffset = NSMakeSize(0.0, 0.0);
   NSImage* image = [self dragImage];
   [self setHidden:YES];
-
-  NSPasteboardItem* pbItem = [NSPasteboardItem new];
-  [pbItem setDataProvider:self forTypes:@[ kBookmarkButtonDragType ]];
-
-  base::scoped_nsobject<NSDraggingItem> dragItem(
-      [[NSDraggingItem alloc] initWithPasteboardWriter:pbItem]);
-  [dragItem setDraggingFrame:[self bounds] contents:image];
-
-  [self beginDraggingSessionWithItems:@[ dragItem.get() ]
-                                event:event
-                               source:self];
-  while (gDraggedButton != nil) {
-    [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode
-                             beforeDate:[NSDate distantFuture]];
-  }
+  [self dragImage:image at:NSMakePoint(0, yAt) offset:dragOffset
+            event:event pasteboard:pboard source:self slideBack:YES];
   [self setHidden:NO];
 
   // And we're done.
   dragPending_ = NO;
   gDraggedButton = nil;
 
   [self autorelease];
 }
 
-- (void)pasteboard:(NSPasteboard*)sender
-                  item:(NSPasteboardItem*)item
-    provideDataForType:(NSString*)type {
-  [sender setData:[NSData dataWithBytes:&gDraggedButton
-                                 length:sizeof(gDraggedButton)]
-          forType:kBookmarkButtonDragType];
-}
-
-- (NSDragOperation)draggingSession:(NSDraggingSession*)session
-    sourceOperationMaskForDraggingContext:(NSDraggingContext)context {
-  NSDragOperation operation = NSDragOperationCopy;
-
-  if (context == NSDraggingContextWithinApplication)
-    operation |= NSDragOperationMove;
-
-  if ([delegate_ canDragBookmarkButtonToTrash:self])
-    operation |= NSDragOperationDelete;
-
-  return operation;
-}
-
 // Overridden to release bar visibility.
 - (DraggableButtonResult)endDrag {
   gDraggedButton = nil;
 
   // visibilityDelegate_ can be nil if we're detached, and that's fine.
   [visibilityDelegate_ releaseBarVisibilityForOwner:self
                                       withAnimation:YES
                                               delay:YES];
   visibilityDelegate_ = nil;
 
   return kDraggableButtonImplUseBase;
 }
 
-- (void)draggingSession:(NSDraggingSession*)session
-           endedAtPoint:(NSPoint)aPoint
-              operation:(NSDragOperation)operation {
+- (NSDragOperation)draggingSourceOperationMaskForLocal:(BOOL)isLocal {
+  NSDragOperation operation = NSDragOperationCopy;
+  if (isLocal) {
+    operation |= NSDragOperationMove;
+  }
+  if ([delegate_ canDragBookmarkButtonToTrash:self]) {
+    operation |= NSDragOperationDelete;
+  }
+  return operation;
+}
+
+- (void)draggedImage:(NSImage *)anImage
+             endedAt:(NSPoint)aPoint
+           operation:(NSDragOperation)operation {
   gDraggedButton = nil;
   // Inform delegate of drag source that we're finished dragging,
   // so it can close auto-opened bookmark folders etc.
   [delegate_ bookmarkDragDidEnd:self
                       operation:operation];
   // Tell delegate if it should delete us.
   if (operation & NSDragOperationDelete) {
     dragEndScreenLocation_ = aPoint;
     [delegate_ didDragBookmarkToTrash:self];
   }
@@ skipping 61 matching lines @@
         break;
       }
       default:
         /* Ignore any other kind of event. */
         break;
     }
   }
   return kDraggableButtonMixinDidWork;
 }
 
+
+
 // mouseEntered: and mouseExited: are called from our
 // BookmarkButtonCell.  We redirect this information to our delegate.
 // The controller can then perform menu-like actions (e.g. "hover over
 // to open menu").
 - (void)mouseEntered:(NSEvent*)event {
   [delegate_ mouseEnteredButton:self event:event];
 }
 
 // See comments above mouseEntered:.
 - (void)mouseExited:(NSEvent*)event {
@@ skipping 81 matching lines @@
 // ThemedWindowDrawing implementation.
 
 - (void)windowDidChangeTheme {
   [self setNeedsDisplay:YES];
 }
 
 - (void)windowDidChangeActive {
   [self setNeedsDisplay:YES];
 }
 
+@end
+
+@implementation BookmarkButton(Private)
+
+
 - (void)installCustomTrackingArea {
   const NSTrackingAreaOptions options =
       NSTrackingActiveAlways |
       NSTrackingMouseEnteredAndExited |
       NSTrackingEnabledDuringMouseDrag;
 
   if (area_) {
     [self removeTrackingArea:area_];
     [area_ release];
   }
 
   area_ = [[NSTrackingArea alloc] initWithRect:[self bounds]
                                        options:options
                                          owner:self
                                       userInfo:nil];
   [self addTrackingArea:area_];
 }
 
+
 - (NSImage*)dragImage {
   NSRect bounds = [self bounds];
   base::scoped_nsobject<NSImage> image(
       [[NSImage alloc] initWithSize:bounds.size]);
   [image lockFocusFlipped:[self isFlipped]];
 
   NSGraphicsContext* context = [NSGraphicsContext currentContext];
   CGContextRef cgContext = static_cast<CGContextRef>([context graphicsPort]);
   CGContextBeginTransparencyLayer(cgContext, 0);
   CGContextSetAlpha(cgContext, kDragImageOpacity);
 
   GradientButtonCell* cell =
       base::mac::ObjCCastStrict<GradientButtonCell>([self cell]);
   [[cell clipPathForFrame:bounds inView:self] setClip];
   [cell drawWithFrame:bounds inView:self];
 
   CGContextEndTransparencyLayer(cgContext);
   [image unlockFocus];
 
   return image.autorelease();
 }
 
-@end
+@end  // @implementation BookmarkButton(Private)