Initial checkin of the new Mozart compositor.

services/gfx/compositor/render/painting.h

+// Copyright 2015 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 SERVICES_GFX_COMPOSITOR_RENDER_PAINTING_H_
+#define SERVICES_GFX_COMPOSITOR_RENDER_PAINTING_H_
+
+#include <map>
+#include <memory>
+
+#include "base/macros.h"
+#include "mojo/skia/ganesh_context.h"
+#include "skia/ext/refptr.h"
+
+class SkImage;
+class SkPicture;
+
+namespace compositor {
+
+class PaintingCache;
+class RenderImage;
+class RenderLayer;
+
+// Provides a context for painting the contents of render tree.
+//
+// This scope should only be instantiated on the stack since it sets up
+// thread-local state for the duration of painting operations.
+class PaintingScope {
+ public:
+  PaintingScope(const mojo::skia::GaneshContext::Scope& ganesh_scope,
+                PaintingCache* painting_cache);
+  ~PaintingScope();
+
+  // Gets the Ganesh scope.

[abarth, 2016/01/10 22:55:36]

Kind of a useless comment.

[jeffbrown, 2016/01/16 03:28:32]

Yeah, habits from documenting public APIs.  I'll remove this.

+  const mojo::skia::GaneshContext::Scope& ganesh_scope() const {
+    return ganesh_scope_;
+  }
+
+  // Gets the painting cache.

[abarth, 2016/01/10 22:55:36]

Kind of a useless comment.

[jeffbrown, 2016/01/16 03:28:32]

Done.

+  PaintingCache* painting_cache() const { return painting_cache_; }
+
+ private:
+  const mojo::skia::GaneshContext::Scope& ganesh_scope_;
+  PaintingCache* const painting_cache_;

[abarth, 2016/01/10 22:55:36]

If this isn't nullable, consider "const PaintingCache&"

[jeffbrown, 2016/01/16 03:28:32]

It can't be const though and non-const references are verboten.  Alas.

+
+  DISALLOW_COPY_AND_ASSIGN(PaintingScope);
+};
+
+// Caches assets between painting invocations to improve efficiency.
+class PaintingCache {
+ public:
+  PaintingCache();
+
+  // The destructor must only be called after the cache has been cleared.
+  ~PaintingCache();
+
+  // Clears the painting cache.
+  // Since clearing the cache may cause textures to be deallocated, we require
+  // that this work happen within a painting scope before the cache is
+  // destroyed.
+  void Clear(const PaintingScope& painting_scope);
+
+  // Obtains an SkImage for the specified render image.
+  // Reuses a previously cached image if possible.
+  // Returns null if the image could not be allocated.
+  skia::RefPtr<SkImage> GetSkImage(const PaintingScope& painting_scope,
+                                   const std::shared_ptr<RenderImage>& image);
+
+  // Obtains an SkPicture for the specified render layer.
+  // Reuses a previously cached pcture if possible.
+  // Result is never null.
+  skia::RefPtr<SkPicture> GetSkPicture(
+      const PaintingScope& painting_scope,
+      const std::shared_ptr<RenderLayer>& layer);
+
+ private:
+  friend class PaintingScope;
+
+  // Informs the cache that painting is about to begin.
+  void BeginPainting(const PaintingScope& painting_scope);
+
+  // Informs the cache that painting has finished.
+  // This provides a signal to the cache that it may discard unused
+  // cached resources that it no longer needs.
+  void FinishPainting(const PaintingScope& painting_scope);
+
+  bool painting_ = false;
+
+  std::map<std::weak_ptr<RenderImage>,
+           skia::RefPtr<SkImage>,
+           std::owner_less<std::weak_ptr<RenderImage>>> used_images_;

[abarth, 2016/01/10 22:55:36]

No idea what this does.

map instead of unordered_map?

[jeffbrown, 2016/01/16 03:28:32]

http://en.cppreference.com/w/cpp/memory/owner_less

But now that you mention it, an unordered map might work fine here...

[jeffbrown, 2016/01/16 03:43:40]

Ahh sadly there's no std::hash<> defined for std::weak_ptr.

+  std::map<std::weak_ptr<RenderImage>,
+           skia::RefPtr<SkImage>,
+           std::owner_less<std::weak_ptr<RenderImage>>> cached_images_;
+
+  std::map<std::weak_ptr<RenderLayer>,
+           skia::RefPtr<SkPicture>,
+           std::owner_less<std::weak_ptr<RenderLayer>>> used_pictures_;
+  std::map<std::weak_ptr<RenderLayer>,
+           skia::RefPtr<SkPicture>,
+           std::owner_less<std::weak_ptr<RenderLayer>>> cached_pictures_;
+};
+
+}  // namespace compositor
+
+#endif  // SERVICES_GFX_COMPOSITOR_RENDER_PAINTING_H_