Fix MIDI code for 64 bit build.

media/midi/midi_manager_mac.cc

 // Copyright (c) 2013 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 "media/midi/midi_manager_mac.h"
 
 #include <iostream>
 #include <string>
 
 #include "base/debug/trace_event.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/sys_string_conversions.h"
 #include <CoreAudio/HostTime.h>
 
 using base::IntToString;
 using base::SysCFStringRefToUTF8;
 using std::string;
 
+// NB: System MIDI types are pointer types in 32-bit and integer types in
+// 64-bit. Therefore, the initialization is the simplest one that satisfies both
+// (if possible).
+
 namespace media {
 
 MIDIManager* MIDIManager::Create() {
   return new MIDIManagerMac();
 }
 
 MIDIManagerMac::MIDIManagerMac()
-    : midi_client_(NULL),
-      coremidi_input_(NULL),
-      coremidi_output_(NULL),
+    : midi_client_(0),
+      coremidi_input_(0),
+      coremidi_output_(0),
       packet_list_(NULL),
       midi_packet_(NULL) {
 }
 
 bool MIDIManagerMac::Initialize() {
   TRACE_EVENT0("midi", "MIDIManagerMac::Initialize");
 
   // CoreMIDI registration.
-  midi_client_ = NULL;
+  midi_client_ = 0;
   OSStatus result = MIDIClientCreate(
       CFSTR("Google Chrome"),
       NULL,
       NULL,
       &midi_client_);
 
   if (result != noErr)
     return false;
 
-  coremidi_input_ = NULL;
+  coremidi_input_ = 0;
 
   // Create input and output port.
   result = MIDIInputPortCreate(
       midi_client_,
       CFSTR("MIDI Input"),
       ReadMidiDispatch,
       this,
       &coremidi_input_);
   if (result != noErr)
     return false;
@@ skipping 18 matching lines @@
     MIDIPortInfo info = GetPortInfoFromEndpoint(destination);
     AddOutputPort(info);
   }
 
   // Open connections from all sources.
   int source_count = MIDIGetNumberOfSources();
 
   for (int i = 0; i < source_count; ++i)  {
     // Receive from all sources.
     MIDIEndpointRef src = MIDIGetSource(i);
-    MIDIPortConnectSource(coremidi_input_, src, src);
+    MIDIPortConnectSource(coremidi_input_, src, reinterpret_cast<void*>(src));
 
     // Keep track of all sources (known as inputs in Web MIDI API terminology).
     source_map_[src] = i;
 
     MIDIPortInfo info = GetPortInfoFromEndpoint(src);
     AddInputPort(info);
   }
 
   // TODO(crogers): Fix the memory management here!
   packet_list_ = reinterpret_cast<MIDIPacketList*>(midi_buffer_);
   midi_packet_ = MIDIPacketListInit(packet_list_);
 
   return true;
 }
 
 MIDIManagerMac::~MIDIManagerMac() {
   if (coremidi_input_)
     MIDIPortDispose(coremidi_input_);
   if (coremidi_output_)
     MIDIPortDispose(coremidi_output_);
 }
 
 void MIDIManagerMac::ReadMidiDispatch(const MIDIPacketList* packet_list,
                                       void* read_proc_refcon,
                                       void* src_conn_refcon) {
   MIDIManagerMac* manager = static_cast<MIDIManagerMac*>(read_proc_refcon);
+#if __LP64__
+  MIDIEndpointRef source = reinterpret_cast<uintptr_t>(src_conn_refcon);
+#else
   MIDIEndpointRef source = static_cast<MIDIEndpointRef>(src_conn_refcon);
+#endif
 
   // Dispatch to class method.
   manager->ReadMidi(source, packet_list);
 }
 
 void MIDIManagerMac::ReadMidi(MIDIEndpointRef source,
                               const MIDIPacketList* packet_list) {
   // Lookup the port index based on the source.
   SourceMap::iterator j = source_map_.find(source);
   if (j == source_map_.end())
@@ skipping 72 matching lines @@
   UInt64 nanoseconds = AudioConvertHostTimeToNanos(timestamp);
   return static_cast<double>(nanoseconds) / 1.0e9;
 }
 
 MIDITimeStamp MIDIManagerMac::SecondsToMIDITimeStamp(double seconds) {
   UInt64 nanos = UInt64(seconds * 1.0e9);
   return AudioConvertNanosToHostTime(nanos);
 }
 
 }  // namespace media