Motown in-proc streaming framework used to implement media services.

services/media/framework/allocator.cc

+// Copyright 2016 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 <cstdlib>
+
+#include "base/logging.h"
+#include "services/media/framework/allocator.h"
+
+namespace mojo {
+namespace media {
+
+namespace {
+
+class DefaultAllocator : public Allocator {
+ public:
+  // Allocator implementation.
+  void* AllocatePayloadBuffer(uint64_t size) override;
+
+  void ReleasePayloadBuffer(uint64_t size, void* buffer) override;
+};
+
+void* DefaultAllocator::AllocatePayloadBuffer(uint64_t size) {
+  DCHECK(size > 0);
+  return std::malloc(static_cast<size_t>(size));
+}
+
+void DefaultAllocator::ReleasePayloadBuffer(uint64_t size, void* buffer) {
+  DCHECK(size > 0);
+  DCHECK(buffer);
+  std::free(buffer);
+}
+
+static DefaultAllocator default_allocator;

[johngro, 2016/01/20 00:25:32]

I think that static-scoped classes are supposed to be marked constexpr to insure
that they have no runtime initialization.  Static and global classes with
runtime initialization are disallowed by style to prevent initialization
ordering bugs.

[dalesat, 2016/01/25 23:29:37]

I'm not sure what to do here in that case. I can't declare default_allocator
constexpr, because GetDefault returns a non-const pointer. This is true even
when I make the constructor constexpr. The compiler won't allow me to also make
the method implementations constexpr. I could lazy-create the default allocator,
but would require a lock. Suggestions?

[johngro, 2016/01/27 22:35:22]

const_cast is your friend.  I banged out a simple example below which follows
the pattern you are attempting to implement here.  Change any of the #if 0s to
#if 1s to see why the constexpr-ness of the static declaration prevents runtime
side effects during construction/destruction, but still allows non-const member
functions.  Also, note that you can still have member variables with
initializers and constructors which take parameters, provided that they are all
evaluate-able at compile time (eg, constexpr).

uint32_t ThisFunctionIsNotConstexpr() { return 4; }

class MyStaticBaseClass {
 public:
  static MyStaticBaseClass* GetDefault();
  virtual void Foo() = 0;
};

class MyStaticClass : public MyStaticBaseClass {
 public:
#if 0
  constexpr MyStaticClass() {
    foo_var_ = ThisFunctionIsNotConstexpr();
  }
#else
  constexpr MyStaticClass() { }
#endif

#if 0
  ~MyStaticClass() { }
#endif

  void Foo() override;
 private:
#if 0
  uint32_t foo_var_ = ThisFunctionIsNotConstexpr();
#else
  uint32_t foo_var_ = 5;
#endif
};

static constexpr MyStaticClass default_static_class;

MyStaticBaseClass* MyStaticBaseClass::GetDefault() {
  return const_cast<MyStaticClass*>(&default_static_class);
}

void MyStaticClass::Foo() {
  LOG(INFO) << "I was called " << __PRETTY_FUNCTION__
            << " foo_var was " << foo_var_;
}

int main(int argc, char** argv) {
  MyStaticBaseClass::GetDefault()->Foo();
  return 0;
}

[dalesat, 2016/01/28 18:49:15]

Done.

+
+} // namespace
+
+// static
+Allocator* Allocator::GetDefault() {
+  return &default_allocator;
+}
+
+} // namespace media
+} // namespace mojo