ViaAndroidSDK for DM

dm/DMSrcSinkAndroid.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "DMSrcSink.h"
 #include "DMSrcSinkAndroid.h"
 
 #include "AnimationContext.h"
 #include "DisplayListRenderer.h"
 #include "IContextFactory.h"
 #include "RenderNode.h"
+#include "SkDrawFilter.h"
+#include "SkiaCanvasProxy.h"
+#include "SkMaskFilter.h"
+#include "SkPictureRecorder.h"
+#include "SkStream.h"
 #include "android/rect.h"
 #include "android/native_window.h"
 #include "gui/BufferQueue.h"
 #include "gui/CpuConsumer.h"
 #include "gui/IGraphicBufferConsumer.h"
 #include "gui/IGraphicBufferProducer.h"
 #include "gui/Surface.h"
 #include "renderthread/RenderProxy.h"
 #include "renderthread/TimeLord.h"
 
-namespace DM {
+/* These functions should only be compiled in the Android Framework. */
 
-/* These functions are only compiled in the Android Framework. */
+namespace {
 
+/**
+ * An SkDrawFilter implementation which removes all flags and features
+ * not exposed by the Android SDK.
+ */
+class ViaAndroidSDKFilter : public SkDrawFilter {
+
+    inline void checkShader(SkPaint* paint, SkShader* shader) {

[mtklein, 2015/03/03 15:55:14]

I think this can be static void CheckShader(SkPaint* paint) ?  Passing shader
alongside makes it seems like it's another shader than paint->geShader().  If
you need to keep the second argument, let's pass it by const SkShader&, to make
it clear we're relying on the results of the null check in filter().

[mtklein, 2015/03/03 15:55:14]

Just FYI, this inline is redundant here.

[tomhudson, 2015/03/05 14:53:52]

Done.

[tomhudson, 2015/03/05 14:53:52]

Yeah, I was offended by calling SkPaint::getShader() once in each context, but
it's really not bad.

+        if (shader->asABitmap(NULL, NULL, NULL) == SkShader::kDefault_BitmapType) {
+            return;
+        }
+        if (shader->asACompose(NULL)) {
+            return;
+        }
+        SkShader::GradientType gtype = shader->asAGradient(NULL);
+        if (gtype == SkShader::kLinear_GradientType ||
+            gtype == SkShader::kRadial_GradientType ||
+            gtype == SkShader::kSweep_GradientType) {
+            return;
+        }
+        paint->setShader(NULL);
+    }
+
+    virtual bool filter(SkPaint* paint, Type drawType) SK_OVERRIDE {

[mtklein, 2015/03/03 15:55:14]

We've been using just SK_OVERRIDE for overrides lately.

[tomhudson, 2015/03/05 14:53:51]

Done.

+
+        uint32_t flags = paint->getFlags();
+        flags &= ~SkPaint::kLCDRenderText_Flag;
+        paint->setFlags(flags);
+
+        // Force bilinear scaling or none
+        if (paint->getFilterQuality() != kNone_SkFilterQuality) {
+            paint->setFilterQuality(kLow_SkFilterQuality);
+        }
+
+        SkShader * shader = paint->getShader();

[mtklein, 2015/03/03 15:55:14]

Can't decide where to put your *s?

[tomhudson, 2015/03/05 14:53:52]

Done.

+        if (shader) {

[mtklein, 2015/03/03 15:55:14]

Might want to write these checks like this, to scope the new variable even
tighter:

if (SkShader* shader = paint->getShader()) {
  this->checkShader(paint, shader);
}

[tomhudson, 2015/03/05 14:53:52]

Acknowledged.

+            checkShader(paint, shader);

[mtklein, 2015/03/03 15:55:14]

this->

[tomhudson, 2015/03/05 14:53:52]

Acknowledged.

+        }
+
+        // GlopBuilder only supports mode & matrix color filters
+        SkColorFilter * cf = paint->getColorFilter();
+        if (cf) {
+            SkColor color;
+            SkXfermode::Mode mode;
+            SkScalar srcColorMatrix[20];
+            if (!cf->asColorMode(&color, &mode) && !cf->asColorMatrix(srcColorMatrix)) {
+                paint->setColorFilter(NULL);
+            }
+        }
+
+        SkPathEffect* pe = paint->getPathEffect();
+        if (pe && !pe->exposedInAndroidJavaAPI()) {
+            paint->setPathEffect(NULL);
+        }
+
+        // TODO: Android doesn't support all the flags that can be passed to
+        // blur filters; we need plumbing to get them out.
+
+        paint->setImageFilter(NULL);
+        paint->setLooper(NULL);
+
+        return true;
+    };
+};
+
+/**
+ * Helper class for setting up android::uirenderer::renderthread::RenderProxy.
+ */
 class ContextFactory : public android::uirenderer::IContextFactory {
 public:
     android::uirenderer::AnimationContext* createAnimationContext
         (android::uirenderer::renderthread::TimeLord& clock) SK_OVERRIDE {
         return new android::uirenderer::AnimationContext(clock);
     }
 };
 
+}  // namespace
+
+namespace DM {
+
 Error HWUISink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString*) const {
     // Do all setup in this function because we don't know the size
     // for the RenderNode and RenderProxy during the constructor.
     // In practice this doesn't seem too expensive.
     const SkISize size = src.size();
 
     // Based on android::SurfaceTexture_init()
     android::sp<android::IGraphicBufferProducer> producer;
     android::sp<android::IGraphicBufferConsumer> consumer;
     android::BufferQueue::createBufferQueue(&producer, &consumer);
@@ skipping 101 matching lines @@
     success =
         nativeWrapper.readPixels(destinationConfig, dst->getPixels(), dst->rowBytes(), 0, 0);
     if (!success) {
         return "Failed to extract pixels from HWUI buffer";
     }
 
     cpuConsumer->unlockBuffer(nativeBuffer);
     return "";
 }
 
+/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
+
+ViaAndroidSDK::ViaAndroidSDK(Sink* sink) : fSink(sink), fFilter (new ViaAndroidSDKFilter()) { }
+
+Error ViaAndroidSDK::draw(const Src& src,
+                          SkBitmap* bitmap,
+                          SkWStream* stream,
+                          SkString* log) const {
+    SkISize size = src.size();
+    SkPictureRecorder recorder;
+    Error err = src.draw(recorder.beginRecording(size.width(), size.height()));
+    if (!err.isEmpty()) {
+        return err;
+    }
+    SkAutoTUnref<SkPicture> pic(recorder.endRecording());
+
+    struct ProxySrc : public Src {
+        const Src& fSrc;
+        const SkPicture* fPic;
+        const SkDrawFilter* fFilter;
+
+        ProxySrc(const Src& src, const SkPicture* pic, SkDrawFilter* filter)
+            : fSrc(src), fPic(pic), fFilter(filter) {}
+
+        Error draw(SkCanvas* canvas) const SK_OVERRIDE {
+            // Route through HWUI's upper layers to change draw operations
+            android::Canvas* ac = android::Canvas::create_canvas(canvas);

[mtklein, 2015/03/03 15:55:14]

SkAutoTDelete?

[tomhudson, 2015/03/05 14:53:52]

Done.

+            SkAutoTUnref<android::uirenderer::SkiaCanvasProxy> scProxy
+                (new android::uirenderer::SkiaCanvasProxy(ac));
+
+            // Route through a draw filter to change paint fields
+            scProxy->setDrawFilter((ViaAndroidSDKFilter*) fFilter);
+
+            scProxy->drawPicture(fPic);

[mtklein, 2015/03/03 15:55:14]

Let's try fSrc.draw(scProxy) and drop the picture.

[tomhudson, 2015/03/05 14:53:51]

Done.

+
+            delete ac;
+            return "";
+        }
+        SkISize size() const SK_OVERRIDE { return fSrc.size(); }
+        Name name() const SK_OVERRIDE { sk_throw(); return ""; }
+    } proxy(src, pic, fFilter.get());
+
+    return fSink->draw(proxy, bitmap, stream, log);
+}
+
 }  // namespace DM