Fix linux build break

dbus/message_unittest.cc

 // Copyright (c) 2011 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 "dbus/message.h"
+
+#include "base/basictypes.h"
 #include "base/logging.h"
-#include "dbus/message.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Test that a byte can be properly written and read. We only have this
 // test for byte, as repeating this for other basic types is too redundant.
 TEST(MessageTest, AppendAndPopByte) {
   dbus::Message message;
   message.reset_raw_message(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL));
   dbus::MessageWriter writer(&message);
   writer.AppendByte(123);  // The input is 123.
 
@@ skipping 228 matching lines @@
         array_writer.OpenVariant("a{sx}", &variant_writer);
         {
           // Opens an array of string-to-int64 dict entries.
           dbus::MessageWriter dict_array_writer(&message);
           variant_writer.OpenArray("{sx}", &dict_array_writer);
           {
             // Opens a string-to-int64 dict entries.
             dbus::MessageWriter dict_entry_writer(&message);
             dict_array_writer.OpenDictEntry(&dict_entry_writer);
             dict_entry_writer.AppendString("foo");
-            dict_entry_writer.AppendInt64(1234567890123456789);
+            dict_entry_writer.AppendInt64(GG_INT64_C(1234567890123456789));
             dict_array_writer.CloseContainer(&dict_entry_writer);
           }
           variant_writer.CloseContainer(&dict_array_writer);
         }
         array_writer.CloseContainer(&variant_writer);
       }
     }
     writer.CloseContainer(&array_writer);
   }
   // What we have created looks like this:
@@ skipping 49 matching lines @@
       dbus::MessageReader dict_array_reader(&message);
       ASSERT_TRUE(variant_reader.PopArray(&dict_array_reader));
       {
         dbus::MessageReader dict_entry_reader(&message);
         ASSERT_TRUE(dict_array_reader.PopDictEntry(&dict_entry_reader));
         std::string string_value;
         ASSERT_TRUE(dict_entry_reader.PopString(&string_value));
         EXPECT_EQ("foo", string_value);
         int64 int64_value = 0;
         ASSERT_TRUE(dict_entry_reader.PopInt64(&int64_value));
-        EXPECT_EQ(1234567890123456789, int64_value);
+        EXPECT_EQ(GG_INT64_C(1234567890123456789), int64_value);
       }
       ASSERT_FALSE(dict_array_reader.HasMoreData());
     }
     ASSERT_FALSE(variant_reader.HasMoreData());
   }
   ASSERT_FALSE(array_reader.HasMoreData());
   ASSERT_FALSE(reader.HasMoreData());
 }
 
 TEST(MessageTest, Message) {
@@ skipping 27 matching lines @@
   EXPECT_TRUE(response.raw_message() == NULL);
   response.reset_raw_message(
       dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN));
   EXPECT_EQ(dbus::Message::MESSAGE_METHOD_RETURN, response.GetMessageType());
 }
 
 TEST(MessageTest, ToString_EmptyMessage) {
   dbus::Message message;
   EXPECT_EQ("", message.ToString());
 }