Initial commit of the blimp/ folder and target

blimp/client/compositor/blimp_compositor_android.cc

+// 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.
+
+#include "blimp/client/compositor/blimp_compositor_android.h"
+
+#include <android/native_window_jni.h>
+
+#include "base/command_line.h"
+#include "base/memory/scoped_ptr.h"
+#include "ui/gfx/geometry/size.h"
+
+namespace {
+// The minimum valid content width in a tile.  This is used to make sure the
+// width of the content on the rightmost tile isn't a tiny sliver.
+const int kMinimumTileContentWidthPixels = 64;
+}
+
+namespace blimp {
+
+// static
+scoped_ptr<BlimpCompositorAndroid> BlimpCompositorAndroid::Create(
+    const gfx::Size& physical_size,
+    const gfx::Size& display_size,
+    float device_scale_factor) {
+  gfx::Size device_size(physical_size);
+  bool real_size_supported = true;
+  if (device_size.IsEmpty()) {
+    real_size_supported = false;
+    device_size = display_size;
+  }
+  return make_scoped_ptr(new BlimpCompositorAndroid(
+      device_size, real_size_supported, device_scale_factor));
+}
+
+BlimpCompositorAndroid::BlimpCompositorAndroid(const gfx::Size& device_size,
+                                               bool real_size_supported,
+                                               float device_scale_factor)
+    : BlimpCompositor(device_scale_factor),
+      portrait_width_(std::min(device_size.width(), device_size.height())),
+      landscape_width_(std::max(device_size.width(), device_size.height())),
+      real_size_supported_(real_size_supported),
+      window_(nullptr) {}
+
+BlimpCompositorAndroid::~BlimpCompositorAndroid() {
+  SetSurface(nullptr, 0 /* null surface */);
+}
+
+void BlimpCompositorAndroid::SetSurface(JNIEnv* env, jobject jsurface) {
+  if (window_) {
+    SetVisible(false);
+    ANativeWindow_release(window_);
+    window_ = nullptr;
+  }
+
+  if (!jsurface)
+    return;
+
+  base::android::ScopedJavaLocalFrame scoped_local_reference_frame(env);
+  window_ = ANativeWindow_fromSurface(env, jsurface);
+  SetVisible(true);
+}
+
+gfx::AcceleratedWidget BlimpCompositorAndroid::GetWindow() {
+  return window_;
+}
+
+void BlimpCompositorAndroid::GenerateLayerTreeSettings(
+    cc::LayerTreeSettings* settings) {
+  BlimpCompositor::GenerateLayerTreeSettings(settings);
+
+  // Calculate the correct raster tile size to use.  Assuming a square tile.
+  DCHECK_EQ(settings->default_tile_size.width(),
+            settings->default_tile_size.height());
+
+  int default_tile_size = settings->default_tile_size.width();
+  if (real_size_supported_) {
+    // Maximum HD dimensions should be 768x1280
+    // Maximum FHD dimensions should be 1200x1920
+    if (portrait_width_ > 768 || landscape_width_ > 1280)
+      default_tile_size = 384;
+    if (portrait_width_ > 1200 || landscape_width_ > 1920)
+      default_tile_size = 512;
+
+    // Adjust for some resolutions that barely straddle an extra
+    // tile when in portrait mode. This helps worst case scroll/raster

[Wez, 2015/09/03 18:26:11]

Why do we only do this optimization for real_size_supported_?

[David Trainor- moved to gerrit, 2015/09/03 19:06:00]

That's the way render_widget_compositor is handling it.  I'm doing the same
thing here.  If we want to change this further let's look into doing it for both
places separately.

[Wez, 2015/09/03 19:56:07]

Acknowledged.

+    // by not needing a full extra tile for each row.
+    int right_tile_width = (portrait_width_ - 1) % default_tile_size + 1;

[Wez, 2015/09/03 18:26:11]

nit: Brackets around the % to make it clear that it's (A % B) +1, not A & (B +
1)

[David Trainor- moved to gerrit, 2015/09/03 19:06:01]

Done.

+    if (right_tile_width < kMinimumTileContentWidthPixels) {
+      // Figure out the new tile count without the small edge tile.
+      int new_tile_count = std::ceil(static_cast<float>(portrait_width_) /
+                                     static_cast<float>(default_tile_size)) -
+                           1;

[Wez, 2015/09/03 18:26:11]

Isn't ceil(A/B) - 1 in practice floor(A/B) in this situation? i.e. we can just
say:

full_tile_count = A / B;

and then say that we're going to expand the tile size to ensure we have only
that many tiles?

[David Trainor- moved to gerrit, 2015/09/03 19:06:01]

Yeah that should work.  Especially since we already know that we overflow a bit.

+      DCHECK_GT(new_tile_count, 0);
+
+      // Calculate the ideal new tile width with the new tile count.
+      default_tile_size = std::ceil(static_cast<float>(portrait_width_) /
+                                    static_cast<float>(new_tile_count));
+
+      // Round up to nearest 32.

[Wez, 2015/09/03 18:26:11]

nit: Explain why - sounds like this is for GPU efficiency?

[David Trainor- moved to gerrit, 2015/09/03 19:06:01]

Done.

+      if (default_tile_size & 0x1F)
+        default_tile_size = (default_tile_size & ~0x1F) + 32;
+    }
+  } else {
+    // We don't know the exact resolution due to screen controls etc., so this
+    // just estimates the values above using tile counts.
+    int numTiles = (portrait_width_ * landscape_width_) / (256 * 256);
+    if (numTiles > 16)
+      default_tile_size = 384;
+    if (numTiles >= 40)
+      default_tile_size = 512;
+  }
+  settings->default_tile_size.SetSize(default_tile_size, default_tile_size);
+}
+
+}  // namespace blimp