remove call to get android MediaPlayer class

chrome/browser/history/android/sqlite_cursor.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 "chrome/browser/history/android/sqlite_cursor.h"
 
 #include "base/android/jni_android.h"
+#include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "chrome/browser/history/android/android_history_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "jni/SQLiteCursor_jni.h"
 #include "sql/statement.h"
 
 using base::android::ConvertUTF8ToJavaString;
-using base::android::GetClass;
-using base::android::HasClass;
-using base::android::MethodID;
 using base::android::ScopedJavaLocalRef;
 using content::BrowserThread;
 
 namespace {
 
 SQLiteCursor::JavaColumnType ToJavaColumnType(sql::ColType type) {
   switch (type) {
     case sql::COLUMN_TYPE_INTEGER:
       return SQLiteCursor::NUMERIC;
     case sql::COLUMN_TYPE_FLOAT:
@@ skipping 18 matching lines @@
 
 SQLiteCursor::TestObserver::~TestObserver() {
 }
 
 ScopedJavaLocalRef<jobject> SQLiteCursor::NewJavaSqliteCursor(
     JNIEnv* env,
     const std::vector<std::string>& column_names,
     history::AndroidStatement* statement,
     AndroidHistoryProviderService* service,
     FaviconService* favicon_service) {
-  if (!HasClass(env, kSQLiteCursorClassPath)) {
-    LOG(ERROR) << "Can not find " << kSQLiteCursorClassPath;
-    return ScopedJavaLocalRef<jobject>();
-  }
-
-  ScopedJavaLocalRef<jclass> sclass = GetClass(env, kSQLiteCursorClassPath);
-  jmethodID method_id = MethodID::Get<MethodID::TYPE_INSTANCE>(
-      env, sclass.obj(), "<init>", "(I)V");
-
   SQLiteCursor* cursor = new SQLiteCursor(column_names, statement, service,
                                           favicon_service);
-  ScopedJavaLocalRef<jobject> obj(env,
-      env->NewObject(sclass.obj(), method_id, reinterpret_cast<jint>(cursor)));
-  if (obj.is_null()) {
-    delete cursor;
-    return ScopedJavaLocalRef<jobject>();
-  }
-  return obj;
+  return Java_SQLiteCursor_create(env, reinterpret_cast<jint>(cursor));
 }
 
 bool SQLiteCursor::RegisterSqliteCursor(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 jint SQLiteCursor::GetCount(JNIEnv* env, jobject obj) {
   // Moves to maxium possible position so we will reach the last row, then finds
   // out the total number of rows.
   int current_position = position_;
   int count = MoveTo(env, obj, std::numeric_limits<int>::max() - 1) + 1;
   // Moves back to the previous position.
   MoveTo(env, obj, current_position);
   return count;
 }
 
 ScopedJavaLocalRef<jobjectArray> SQLiteCursor::GetColumnNames(JNIEnv* env,
                                                               jobject obj) {
-  size_t count = column_names_.size();
-  ScopedJavaLocalRef<jclass> sclass = GetClass(env, "java/lang/String");
-  ScopedJavaLocalRef<jobjectArray> arr(env,
-      env->NewObjectArray(count, sclass.obj(), NULL));
-  for (size_t i = 0; i < count; i++) {
-    ScopedJavaLocalRef<jstring> str =
-        ConvertUTF8ToJavaString(env, column_names_[i].c_str());
-    env->SetObjectArrayElement(arr.obj(), i, str.obj());
-  }
-  return arr;
+  return base::android::ToJavaArrayOfStrings(env, column_names_);
 }
 
 ScopedJavaLocalRef<jstring> SQLiteCursor::GetString(JNIEnv* env,
                                                     jobject obj,
                                                     jint column) {
   string16 value = statement_->statement()->ColumnString16(column);
   return ScopedJavaLocalRef<jstring>(env,
       env->NewString(value.data(), value.size()));
 }
 
@@ skipping 14 matching lines @@
                                                      jint column) {
   std::vector<unsigned char> blob;
 
   // Assume the client will only get favicon using GetBlob.
   if (statement_->favicon_index() == column) {
     if (!GetFavicon(statement_->statement()->ColumnInt(column), &blob))
       return ScopedJavaLocalRef<jbyteArray>();
   } else {
     statement_->statement()->ColumnBlobAsVector(column, &blob);
   }
-  ScopedJavaLocalRef<jbyteArray> jb(env, env->NewByteArray(blob.size()));
-  int count = 0;
-  for (std::vector<unsigned char>::const_iterator i = blob.begin();
-      i != blob.end(); ++i) {
-    env->SetByteArrayRegion(jb.obj(), count++, 1, (jbyte *)i);
-  }
-  return jb;
+  return base::android::ToJavaByteArray(env, &blob[0], blob.size());
 }
 
 jboolean SQLiteCursor::IsNull(JNIEnv* env, jobject obj, jint column) {
   return NULL_TYPE == GetColumnTypeInternal(column) ? JNI_TRUE : JNI_FALSE;
 }
 
 jint SQLiteCursor::MoveTo(JNIEnv* env, jobject obj, jint pos) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&SQLiteCursor::RunMoveStatementOnUIThread,
       base::Unretained(this), pos));
@@ skipping 122 matching lines @@
 }
 
 void SQLiteCursor::RunMoveStatementOnUIThread(int pos) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!consumer_.get())
     consumer_.reset(new CancelableRequestConsumer());
   service_->MoveStatement(
       statement_, position_, pos, consumer_.get(),
       base::Bind(&SQLiteCursor::OnMoved, base::Unretained(this)));
 }