Upstream some more content/ DEPS-related cleanup.

content/browser/android/bitmap_holder.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/android/jni_helper.h"
+#include "content/public/browser/android/bitmap_holder.h"
 
 #include <android/bitmap.h>
 #include <vector>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_helper.h"
-#include "base/android/jni_string.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
-#include "jni/jni_helper_jni.h"
+#include "jni/bitmap_holder_jni.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 using base::android::AttachCurrentThread;
 using base::android::CheckException;
-using base::android::GetStaticMethodID;
-using base::android::GetClass;
-using base::android::GetMethodID;
 using base::android::ScopedJavaLocalRef;
 
+namespace content {
+
 AutoLocalFrame::AutoLocalFrame(int capacity) {
   AttachCurrentThread()->PushLocalFrame(capacity);
 }
 
 AutoLocalFrame::~AutoLocalFrame() {
   AttachCurrentThread()->PopLocalFrame(NULL);
 }
 
 AutoLockJavaBitmap::AutoLockJavaBitmap(jobject bitmap) :
     bitmap_(bitmap),
@@ skipping 25 matching lines @@
   return info.format;
 }
 
 uint32_t AutoLockJavaBitmap::stride() const {
   AndroidBitmapInfo info;
   int err = AndroidBitmap_getInfo(AttachCurrentThread(), bitmap_, &info);
   DCHECK(!err);
   return info.stride;
 }
 
-void PrintJavaStackTrace() {
-  JNIEnv* env = AttachCurrentThread();
-
-  ScopedJavaLocalRef<jclass> throwable_clazz =
-      GetClass(env, "java/lang/Throwable");
-  jmethodID throwable_constructor =
-      GetMethodID(env, throwable_clazz, "<init>", "()V");
-
-  ScopedJavaLocalRef<jobject> throwable_object(env,
-      env->NewObject(throwable_clazz.obj(), throwable_constructor));
-  DCHECK(!throwable_object.is_null());
-  jmethodID printstacktrace =
-      GetMethodID(env, throwable_clazz, "printStackTrace", "()V");
-
-  env->CallVoidMethod(throwable_object.obj(), printstacktrace);
-  CheckException(env);
-}
-
-void ConvertJavaArrayOfStringsToVectorOfStrings(
-    JNIEnv* env,
-    jobjectArray jstrings,
-    std::vector<std::string>* vec) {
-  vec->clear();
-  jsize length = env->GetArrayLength(jstrings);
-  for (jsize i = 0; i < length; ++i) {
-    jstring item = static_cast<jstring>(
-        env->GetObjectArrayElement(jstrings, i));
-    vec->push_back(base::android::ConvertJavaStringToUTF8(env, item));
-    env->DeleteLocalRef(item);
-  }
-}
-
 ScopedJavaLocalRef<jobject> CreateJavaBitmap(const gfx::Size& size, bool keep) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> bitmap =
-      Java_JNIHelper_createJavaBitmap(env, size.width(), size.height(), keep);
+      Java_BitmapHolder_createJavaBitmap(
+          env, size.width(), size.height(), keep);
   CheckException(env);
   return bitmap;
 }
 
 void DeleteJavaBitmap(jobject bitmap) {
   JNIEnv* env = AttachCurrentThread();
-  Java_JNIHelper_deleteJavaBitmap(env, bitmap);
+  Java_BitmapHolder_deleteJavaBitmap(env, bitmap);
   CheckException(env);
 }
 
 void PaintJavaBitmapToJavaBitmap(jobject source_bitmap,
                                  const gfx::Rect& source_rect,
                                  jobject dest_bitmap,
                                  const gfx::Rect& dest_rect) {
   TRACE_EVENT0("jni", "PaintJavaBitmapToJavaBitmap");
   JNIEnv* env = AttachCurrentThread();
 
-  Java_JNIHelper_paintJavaBitmapToJavaBitmap(env,
-                                             source_bitmap,
-                                             source_rect.x(),
-                                             source_rect.y(),
-                                             source_rect.right(),
-                                             source_rect.bottom(),
-                                             dest_bitmap,
-                                             dest_rect.x(),
-                                             dest_rect.y(),
-                                             dest_rect.right(),
-                                             dest_rect.bottom());
+  Java_BitmapHolder_paintJavaBitmapToJavaBitmap(env,
+                                                source_bitmap,
+                                                source_rect.x(),
+                                                source_rect.y(),
+                                                source_rect.right(),
+                                                source_rect.bottom(),
+                                                dest_bitmap,
+                                                dest_rect.x(),
+                                                dest_rect.y(),
+                                                dest_rect.right(),
+                                                dest_rect.bottom());
   CheckException(env);
 }
 
 ScopedJavaLocalRef<jobject> ConvertToJavaBitmap(const SkBitmap* skbitmap) {
   TRACE_EVENT0("jni", "ConvertToJavaBitmap");
   DCHECK(skbitmap);
   DCHECK_EQ(skbitmap->bytesPerPixel(), 4);
 
   // Create a temporary java bitmap.
   ScopedJavaLocalRef<jobject> jbitmap =
       CreateJavaBitmap(gfx::Size(skbitmap->width(), skbitmap->height()), false);
 
   // Lock and copy the pixels from the skbitmap.
   SkAutoLockPixels src_lock(*skbitmap);
   AutoLockJavaBitmap dst_lock(jbitmap.obj());
   void* src_pixels = skbitmap->getPixels();
   void* dst_pixels = dst_lock.pixels();
   memcpy(dst_pixels, src_pixels, skbitmap->getSize());
 
   return jbitmap;
 }
 
-bool RegisterJniHelper(JNIEnv* env) {
+} // namespace content
+
+bool RegisterBitmapHolder(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }