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;
+
+// The minimum size increase for tiles (we want them to be multiples of 32).

[Wez, 2015/09/03 00:49:28]

nit: "size increase" doesn't mean much in this context; might be clearer to
express this as the block size of which tile sizes must be a multiple?

Is it the case that the minimum content width must be a multiple of this value?

[David Trainor- moved to gerrit, 2015/09/03 06:33:21]

I'm not sure.  I don't think so.  I think the tiles need to be this size because
it's more efficient for the GPU, but I haven't seen any code that requires the
content area to match this.

+const int kTileSizeIncrementStepPixels = 32;
+}
+
+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,
+    const base::CommandLine& cmd) {
+  BlimpCompositor::GenerateLayerTreeSettings(settings, cmd);
+
+  // 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
+    // by not needing a full extra tile for each row.
+    int right_tile_width = portrait_width_ % default_tile_size;

[Wez, 2015/09/03 00:49:27]

Isn't the rightmost tile width:

((portrait_width_-1) % default_tile_size)+1

i.e. ranging from 1->default_tile_size, not 0->default_tile_size-1?

That would let you get rid of the zero special-case below.

[David Trainor- moved to gerrit, 2015/09/03 06:33:21]

Good idea.  Done.

+    if (right_tile_width != 0 &&
+        right_tile_width < kMinimumTileContentWidthPixels) {
+      int num_full_tiles = portrait_width_ / default_tile_size;
+
+      // Figure out how many increments of kTileSizeIncrementStepPixels are
+      // needed to fill the small remaining gap.
+      int step_increase = std::ceil(
+          static_cast<float>(right_tile_width) /
+          static_cast<float>(num_full_tiles * kTileSizeIncrementStepPixels));

[Wez, 2015/09/03 00:49:28]

It's not clear to me what the connection between the comment and the algebra is
here; it looks like you're trying to work out a small amount to expand the
default tile size by to avoid having a thin sliver down the RHS - so basically
you want to split the right-tile-width amongst the full tiles?
kTileSizeIncrementStepPixels only factors in because you require tiles to be a
multiple of that size - so you should just be able to calculate the ideal target
size and round-up, surely?

[David Trainor- moved to gerrit, 2015/09/03 06:33:21]

Done.

+      default_tile_size += step_increase * kTileSizeIncrementStepPixels;
+    }
+  } 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