Android: Support GPU process

content/browser/renderer_host/compositor_impl_android.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
+#include <map>
 
+#include "base/android/jni_android.h"
+#include "base/android/scoped_java_ref.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/synchronization/lock.h"
 #include "cc/context_provider.h"
 #include "cc/input_handler.h"
 #include "cc/layer.h"
 #include "cc/layer_tree_host.h"
 #include "cc/output_surface.h"
 #include "cc/thread_impl.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/image_transport_factory_android.h"
 #include "content/common/gpu/client/gl_helper.h"
@@ skipping 15 matching lines @@
 namespace {
 
 static bool g_initialized = false;
 static webkit_glue::WebThreadImpl* g_impl_thread = NULL;
 static bool g_use_direct_gl = false;
 
 } // anonymous namespace
 
 namespace content {
 
+typedef std::map<int, base::android::ScopedJavaGlobalRef<jobject> >
+    SurfaceMap;
+static base::LazyInstance<SurfaceMap>
+    g_surface_map = LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<base::Lock> g_surface_map_lock;
+
 // static
 Compositor* Compositor::Create(Client* client) {
   return client ? new CompositorImpl(client) : NULL;
 }
 
 // static
 void Compositor::Initialize() {
   DCHECK(!CompositorImpl::IsInitialized());
   g_initialized = true;
 }
@@ skipping 16 matching lines @@
 // static
 bool CompositorImpl::IsThreadingEnabled() {
   return g_impl_thread;
 }
 
 // static
 bool CompositorImpl::UsesDirectGL() {
   return g_use_direct_gl;
 }
 
+// static
+jobject CompositorImpl::GetSurface(int surface_id) {
+  base::AutoLock lock(g_surface_map_lock.Get());
+  SurfaceMap* surfaces = g_surface_map.Pointer();
+  SurfaceMap::iterator it = surfaces->find(surface_id);
+  jobject jsurface = it == surfaces->end() ? NULL : it->second.obj();
+
+  LOG_IF(WARNING, !jsurface) << "No surface for surface id " << surface_id;
+  return jsurface;
+}
+
 CompositorImpl::CompositorImpl(Compositor::Client* client)
     : root_layer_(cc::Layer::create()),
       has_transparent_background_(false),
       window_(NULL),
       surface_id_(0),
       client_(client),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(client);
 }
 
@@ skipping 25 matching lines @@
     window_ = window;
     ANativeWindow_acquire(window);
     surface_id_ = tracker->AddSurfaceForNativeWidget(window);
     tracker->SetSurfaceHandle(
         surface_id_,
         gfx::GLSurfaceHandle(gfx::kNullPluginWindow, gfx::NATIVE_DIRECT));
     SetVisible(true);
   }
 }
 
+void CompositorImpl::SetSurface(jobject surface) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  base::android::ScopedJavaLocalRef<jobject> j_surface(env, surface);
+  if (surface) {
+    ANativeWindow* window = ANativeWindow_fromSurface(env, surface);
+    SetWindowSurface(window);
+    ANativeWindow_release(window);
+    {
+      base::AutoLock lock(g_surface_map_lock.Get());
+      g_surface_map.Get().insert(std::make_pair(surface_id_, j_surface));
+    }
+  } else {
+    {
+      base::AutoLock lock(g_surface_map_lock.Get());
+      g_surface_map.Get().erase(surface_id_);
+    }
+    SetWindowSurface(NULL);
+  }
+}
+
 void CompositorImpl::SetVisible(bool visible) {
   if (!visible) {
     host_.reset();
   } else if (!host_.get()) {
     cc::LayerTreeSettings settings;
     settings.refreshRate = 60.0;
     settings.implSidePainting = false;
     settings.calculateTopControlsPosition = false;
     settings.topControlsHeight = 0.f;
     settings.useMemoryManagement = false;
@@ skipping 278 matching lines @@
     case ANDROID_BITMAP_FORMAT_RGBA_8888:
       return GL_UNSIGNED_BYTE;
       break;
     case ANDROID_BITMAP_FORMAT_RGB_565:
     default:
       return GL_UNSIGNED_SHORT_5_6_5;
   }
 }
 
 } // namespace content