Use full include paths everywhere

src/lazy-instance.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The LazyInstance<Type, Traits> class manages a single instance of Type,
 // which will be lazily created on the first time it's accessed.  This class is
 // useful for places you would normally use a function-level static, but you
 // need to have guaranteed thread-safety.  The Type constructor will only ever
 // be called once, even if two threads are racing to create the object.  Get()
 // and Pointer() will always return the same, completely initialized instance.
@@ skipping 50 matching lines @@
 // - "Dynamic mode". In this mode, the instance is dynamically allocated and
 //   constructed (using new) by default. This mode is useful if you have to
 //   deal with some code already allocating the instance for you (e.g.
 //   OS::Mutex() which returns a new private OS-dependent subclass of Mutex).
 //   The macro LAZY_DYNAMIC_INSTANCE_INITIALIZER must be used to initialize
 //   dynamic lazy instances.
 
 #ifndef V8_LAZY_INSTANCE_H_
 #define V8_LAZY_INSTANCE_H_
 
-#include "base/macros.h"
-#include "once.h"
+#include "src/base/macros.h"
+#include "src/once.h"
 
 namespace v8 {
 namespace internal {
 
 #define LAZY_STATIC_INSTANCE_INITIALIZER { V8_ONCE_INIT, { {} } }
 #define LAZY_DYNAMIC_INSTANCE_INITIALIZER { V8_ONCE_INIT, 0 }
 
 // Default to static mode.
 #define LAZY_INSTANCE_INITIALIZER LAZY_STATIC_INSTANCE_INITIALIZER
 
@@ skipping 145 matching lines @@
           typename InitOnceTrait = ThreadSafeInitOnceTrait,
           typename DestroyTrait = LeakyInstanceTrait<T> >
 struct LazyDynamicInstance {
   typedef LazyInstanceImpl<T, DynamicallyAllocatedInstanceTrait<T>,
       CreateTrait, InitOnceTrait, DestroyTrait> type;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_LAZY_INSTANCE_H_