Update mojo sdk to rev 3d23dae011859a2aae49f1d1adde705c8e85d819

third_party/mojo_services/src/view_manager/public/cpp/view_property.h

 // 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.
 
 #ifndef MOJO_SERVICES_VIEW_MANAGER_PUBLIC_CPP_VIEW_PROPERTY_H_
 #define MOJO_SERVICES_VIEW_MANAGER_PUBLIC_CPP_VIEW_PROPERTY_H_
 
-#include "base/basictypes.h"
+#include <stdint.h>
 
 // This header should be included by code that defines ViewProperties. It
 // should not be included by code that only gets and sets ViewProperties.
 //
 // To define a new ViewProperty:
 //
 //  #include "view_manager/public/cpp/view_property.h"
 //
 //  DECLARE_EXPORTED_VIEW_PROPERTY_TYPE(FOO_EXPORT, MyType);
 //  namespace foo {
@@ skipping 17 matching lines @@
 //
 //  // outside all namespaces:
 //  DECLARE_EXPORTED_VIEW_PROPERTY_TYPE(FOO_EXPORT, MyType)
 //
 // If a property type is not exported, use DECLARE_VIEW_PROPERTY_TYPE(MyType)
 // which is a shorthand for DECLARE_EXPORTED_VIEW_PROPERTY_TYPE(, MyType).
 
 namespace mojo {
 namespace {
 
-// No single new-style cast works for every conversion to/from int64, so we
+// No single new-style cast works for every conversion to/from int64_t, so we
 // need this helper class. A third specialization is needed for bool because
 // MSVC warning C4800 (forcing value to bool) is not suppressed by an explicit
 // cast (!).
 template <typename T>
 class ViewPropertyCaster {
  public:
-  static int64 ToInt64(T x) { return static_cast<int64>(x); }
-  static T FromInt64(int64 x) { return static_cast<T>(x); }
+  static int64_t ToInt64(T x) { return static_cast<int64_t>(x); }
+  static T FromInt64(int64_t x) { return static_cast<T>(x); }
 };
 template <typename T>
 class ViewPropertyCaster<T*> {
  public:
-  static int64 ToInt64(T* x) { return reinterpret_cast<int64>(x); }
-  static T* FromInt64(int64 x) { return reinterpret_cast<T*>(x); }
+  static int64_t ToInt64(T* x) { return reinterpret_cast<int64_t>(x); }
+  static T* FromInt64(int64_t x) { return reinterpret_cast<T*>(x); }
 };
 template <>
 class ViewPropertyCaster<bool> {
  public:
-  static int64 ToInt64(bool x) { return static_cast<int64>(x); }
-  static bool FromInt64(int64 x) { return x != 0; }
+  static int64_t ToInt64(bool x) { return static_cast<int64_t>(x); }
+  static bool FromInt64(int64_t x) { return x != 0; }
 };
 
 }  // namespace
 
 template <typename T>
 struct ViewProperty {
   T default_value;
   const char* name;
   View::PropertyDeallocator deallocator;
 };
 
 template <typename T>
 void View::SetLocalProperty(const ViewProperty<T>* property, T value) {
-  int64 old = SetLocalPropertyInternal(
+  int64_t old = SetLocalPropertyInternal(
       property, property->name,
       value == property->default_value ? nullptr : property->deallocator,
       ViewPropertyCaster<T>::ToInt64(value),
       ViewPropertyCaster<T>::ToInt64(property->default_value));
   if (property->deallocator &&
       old != ViewPropertyCaster<T>::ToInt64(property->default_value)) {
     (*property->deallocator)(old);
   }
 }
 
@@ skipping 13 matching lines @@
 // Macros to instantiate the property getter/setter template functions.
 #define DECLARE_EXPORTED_VIEW_PROPERTY_TYPE(EXPORT, T)                         \
   template EXPORT void mojo::View::SetLocalProperty(                           \
       const mojo::ViewProperty<T>*, T);                                        \
   template EXPORT T mojo::View::GetLocalProperty(const mojo::ViewProperty<T>*) \
       const;                                                                   \
   template EXPORT void mojo::View::ClearLocalProperty(                         \
       const mojo::ViewProperty<T>*);
 #define DECLARE_VIEW_PROPERTY_TYPE(T) DECLARE_EXPORTED_VIEW_PROPERTY_TYPE(, T)
 
-#define DEFINE_VIEW_PROPERTY_KEY(TYPE, NAME, DEFAULT)                      \
-  COMPILE_ASSERT(sizeof(TYPE) <= sizeof(int64), property_type_too_large);  \
-  namespace {                                                              \
-  const mojo::ViewProperty<TYPE> NAME##_Value = {DEFAULT, #NAME, nullptr}; \
-  }                                                                        \
+#define DEFINE_VIEW_PROPERTY_KEY(TYPE, NAME, DEFAULT)                       \
+  COMPILE_ASSERT(sizeof(TYPE) <= sizeof(int64_t), property_type_too_large); \
+  namespace {                                                               \
+  const mojo::ViewProperty<TYPE> NAME##_Value = {DEFAULT, #NAME, nullptr};  \
+  }                                                                         \
   const mojo::ViewProperty<TYPE>* const NAME = &NAME##_Value;
 
-#define DEFINE_LOCAL_VIEW_PROPERTY_KEY(TYPE, NAME, DEFAULT)                \
-  COMPILE_ASSERT(sizeof(TYPE) <= sizeof(int64), property_type_too_large);  \
-  namespace {                                                              \
-  const mojo::ViewProperty<TYPE> NAME##_Value = {DEFAULT, #NAME, nullptr}; \
-  const mojo::ViewProperty<TYPE>* const NAME = &NAME##_Value;              \
+#define DEFINE_LOCAL_VIEW_PROPERTY_KEY(TYPE, NAME, DEFAULT)                 \
+  COMPILE_ASSERT(sizeof(TYPE) <= sizeof(int64_t), property_type_too_large); \
+  namespace {                                                               \
+  const mojo::ViewProperty<TYPE> NAME##_Value = {DEFAULT, #NAME, nullptr};  \
+  const mojo::ViewProperty<TYPE>* const NAME = &NAME##_Value;               \
   }
 
 #define DEFINE_OWNED_VIEW_PROPERTY_KEY(TYPE, NAME, DEFAULT)            \
   namespace {                                                          \
-  void Deallocator##NAME(int64 p) {                                    \
+  void Deallocator##NAME(int64_t p) {                                  \
     enum { type_must_be_complete = sizeof(TYPE) };                     \
     delete mojo::ViewPropertyCaster<TYPE*>::FromInt64(p);              \
   }                                                                    \
   const mojo::ViewProperty<TYPE*> NAME##_Value = {DEFAULT,             \
                                                   #NAME,               \
                                                   &Deallocator##NAME}; \
   }                                                                    \
   const mojo::ViewProperty<TYPE*>* const NAME = &NAME##_Value;
 
 #endif  // MOJO_SERVICES_VIEW_MANAGER_PUBLIC_CPP_VIEW_PROPERTY_H_