Move some files from ext to src

src/core/arraysize.h

@@ -0,0 +1,34 @@
+// 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.
+
+// From Chromium src/base/macros.h
+
+#include <cstddef>  // For size_t.
+
+// The arraysize(arr) macro returns the # of elements in an array arr.
+// The expression is a compile-time constant, and therefore can be
+// used in defining new arrays, for example.  If you use arraysize on
+// a pointer by mistake, you will get a compile-time error.
+//
+// One caveat is that arraysize() doesn't accept any array of an
+// anonymous type or a type defined inside a function.  In these rare
+// cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below.  This is
+// due to a limitation in C++'s template system.  The limitation might
+// eventually be removed, but it hasn't happened yet.
+
+// This template function declaration is used in defining arraysize.
+// Note that the function doesn't need an implementation, as we only
+// use its type.
+template <typename T, size_t N>
+char (&ArraySizeHelper(T (&array)[N]))[N];
+
+// That gcc wants both of these prototypes seems mysterious. VC, for
+// its part, can't decide which to use (another mystery). Matching of
+// template overloads: the final frontier.
+#ifndef _MSC_VER
+template <typename T, size_t N>
+char (&ArraySizeHelper(const T (&array)[N]))[N];
+#endif
+
+#define arraysize(array) (sizeof(ArraySizeHelper(array)))

src/core/lazy.h

@@ -0,0 +1,65 @@
+/* This file is part of Strawberry.
+   Copyright 2016, John Maguire <john.maguire@gmail.com>
+
+   Strawberry is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   Strawberry is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef LAZY_H
+#define LAZY_H
+
+#include <functional>
+#include <memory>
+
+// Helper for lazy initialization of objects.
+// Usage:
+//    Lazy<Foo> my_lazy_object([]() { return new Foo; });
+
+template <typename T>
+class Lazy {
+ public:
+  explicit Lazy(std::function<T*()> init) : init_(init) {}
+
+  // Convenience constructor that will lazily default construct the object.
+  Lazy() : init_([]() { return new T; }) {}
+
+  T* get() const {
+    CheckInitialized();
+    return ptr_.get();
+  }
+
+  typename std::add_lvalue_reference<T>::type operator*() const {
+    CheckInitialized();
+    return *ptr_;
+  }
+
+  T* operator->() const { return get(); }
+
+  // Returns true if the object is not yet initialized.
+  explicit operator bool() const { return ptr_; }
+
+  // Deletes the underlying object and will re-run the initialization function if the object is requested again.
+  void reset() { ptr_.reset(); }
+
+ private:
+  void CheckInitialized() const {
+    if (!ptr_) {
+      ptr_.reset(init_(), [](T*obj) { obj->deleteLater(); });
+    }
+  }
+
+  const std::function<T*()> init_;
+  mutable std::shared_ptr<T> ptr_;
+};
+
+#endif  // LAZY_H

src/core/scoped_nsautorelease_pool.h

@@ -0,0 +1,38 @@
+// 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.
+
+#ifndef BASE_MAC_SCOPED_NSAUTORELEASE_POOL_H_
+#define BASE_MAC_SCOPED_NSAUTORELEASE_POOL_H_
+
+#include <QObject>
+
+#if defined(__OBJC__)
+@class NSAutoreleasePool;
+#else  // __OBJC__
+class NSAutoreleasePool;
+#endif  // __OBJC__
+
+// ScopedNSAutoreleasePool allocates an NSAutoreleasePool when instantiated and
+// sends it a -drain message when destroyed.  This allows an autorelease pool to
+// be maintained in ordinary C++ code without bringing in any direct Objective-C
+// dependency.
+
+class ScopedNSAutoreleasePool {
+ public:
+  ScopedNSAutoreleasePool();
+  ~ScopedNSAutoreleasePool();
+
+  // Clear out the pool in case its position on the stack causes it to be
+  // alive for long periods of time (such as the entire length of the app).
+  // Only use then when you're certain the items currently in the pool are
+  // no longer needed.
+  void Recycle();
+ private:
+  NSAutoreleasePool* autorelease_pool_;
+
+ private:
+  Q_DISABLE_COPY(ScopedNSAutoreleasePool);
+};
+
+#endif  // BASE_MAC_SCOPED_NSAUTORELEASE_POOL_H_

src/core/scoped_nsautorelease_pool.mm

@@ -0,0 +1,24 @@
+// Copyright (c) 2010 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 "scoped_nsautorelease_pool.h"
+
+#import <Foundation/Foundation.h>
+
+ScopedNSAutoreleasePool::ScopedNSAutoreleasePool()
+    : autorelease_pool_([[NSAutoreleasePool alloc] init]) {
+  Q_ASSERT(autorelease_pool_);
+}
+
+ScopedNSAutoreleasePool::~ScopedNSAutoreleasePool() {
+  [autorelease_pool_ drain];
+}
+
+// Cycle the internal pool, allowing everything there to get cleaned up and
+// start anew.
+void ScopedNSAutoreleasePool::Recycle() {
+  [autorelease_pool_ drain];
+  autorelease_pool_ = [[NSAutoreleasePool alloc] init];
+  Q_ASSERT(autorelease_pool_);
+}