[Android] Rename TabBase to Tab

chrome/browser/android/tab_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 "chrome/browser/android/tab_android.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/debug/trace_event.h"
 #include "chrome/browser/android/chrome_web_contents_delegate_android.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/ui/android/tab_model/tab_model_list.h"
 #include "chrome/browser/ui/android/window_android_helper.h"
 #include "chrome/browser/ui/blocked_content/popup_blocker_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
 #include "chrome/browser/ui/tab_helpers.h"
 #include "chrome/browser/ui/toolbar/toolbar_model_impl.h"
 #include "content/public/browser/android/content_view_core.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
-#include "jni/TabBase_jni.h"
+#include "jni/Tab_jni.h"
 
 TabAndroid* TabAndroid::FromWebContents(content::WebContents* web_contents) {
   CoreTabHelper* core_tab_helper = CoreTabHelper::FromWebContents(web_contents);
   if (!core_tab_helper)
     return NULL;
 
   CoreTabHelperDelegate* core_delegate = core_tab_helper->delegate();
   if (!core_delegate)
     return NULL;
 
   return static_cast<TabAndroid*>(core_delegate);
 }
 
 TabAndroid* TabAndroid::GetNativeTab(JNIEnv* env, jobject obj) {
-  return reinterpret_cast<TabAndroid*>(Java_TabBase_getNativePtr(env, obj));
+  return reinterpret_cast<TabAndroid*>(Java_Tab_getNativePtr(env, obj));
 }
 
 TabAndroid::TabAndroid(JNIEnv* env, jobject obj)
     : weak_java_tab_(env, obj),
       session_tab_id_(),
       synced_tab_delegate_(new browser_sync::SyncedTabDelegateAndroid(this)) {
-  Java_TabBase_setNativePtr(env, obj, reinterpret_cast<intptr_t>(this));
+  Java_Tab_setNativePtr(env, obj, reinterpret_cast<intptr_t>(this));
 }
 
 TabAndroid::~TabAndroid() {
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_tab_.get(env);
   if (obj.is_null())
     return;
 
-  Java_TabBase_clearNativePtr(env, obj.obj());
+  Java_Tab_clearNativePtr(env, obj.obj());
 }
 
 base::android::ScopedJavaLocalRef<jobject> TabAndroid::GetJavaObject() {
   JNIEnv* env = base::android::AttachCurrentThread();
   return weak_java_tab_.get(env);
 }
 
 int TabAndroid::GetAndroidId() const {
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_tab_.get(env);
   if (obj.is_null())
     return -1;
-  return Java_TabBase_getId(env, obj.obj());
+  return Java_Tab_getId(env, obj.obj());
 }
 
 int TabAndroid::GetSyncId() const {
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_tab_.get(env);
   if (obj.is_null())
     return 0;
-  return Java_TabBase_getSyncId(env, obj.obj());
+  return Java_Tab_getSyncId(env, obj.obj());
 }
 
 base::string16 TabAndroid::GetTitle() const {
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_tab_.get(env);
   if (obj.is_null())
     return base::string16();
   return base::android::ConvertJavaStringToUTF16(
-      Java_TabBase_getTitle(env, obj.obj()));
+      Java_Tab_getTitle(env, obj.obj()));
 }
 
 GURL TabAndroid::GetURL() const {
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_tab_.get(env);
   if (obj.is_null())
     return GURL::EmptyGURL();
   return GURL(base::android::ConvertJavaStringToUTF8(
-      Java_TabBase_getUrl(env, obj.obj())));
+      Java_Tab_getUrl(env, obj.obj())));
 }
 
 bool TabAndroid::RestoreIfNeeded() {
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_tab_.get(env);
   if (obj.is_null())
     return false;
-  return Java_TabBase_restoreIfNeeded(env, obj.obj());
+  return Java_Tab_restoreIfNeeded(env, obj.obj());
 }
 
 content::ContentViewCore* TabAndroid::GetContentViewCore() const {
   if (!web_contents())
     return NULL;
 
   return content::ContentViewCore::FromWebContents(web_contents());
 }
 
 Profile* TabAndroid::GetProfile() const {
   if (!web_contents())
     return NULL;
 
   return Profile::FromBrowserContext(web_contents()->GetBrowserContext());
 }
 
 browser_sync::SyncedTabDelegate* TabAndroid::GetSyncedTabDelegate() const {
   return synced_tab_delegate_.get();
 }
 
 void TabAndroid::SetSyncId(int sync_id) {
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_tab_.get(env);
   if (obj.is_null())
     return;
-  Java_TabBase_setSyncId(env, obj.obj(), sync_id);
+  Java_Tab_setSyncId(env, obj.obj(), sync_id);
 }
 
 void TabAndroid::HandlePopupNavigation(chrome::NavigateParams* params) {
   NOTIMPLEMENTED();
 }
 
 void TabAndroid::OnReceivedHttpAuthRequest(jobject auth_handler,
                                            const base::string16& host,
                                            const base::string16& realm) {
   NOTIMPLEMENTED();
@@ skipping 26 matching lines @@
 
 void TabAndroid::SwapTabContents(content::WebContents* old_contents,
                                  content::WebContents* new_contents,
                                  bool did_start_load,
                                  bool did_finish_load) {
   JNIEnv* env = base::android::AttachCurrentThread();
 
   // We need to notify the native InfobarContainer so infobars can be swapped.
   InfoBarContainerAndroid* infobar_container =
       reinterpret_cast<InfoBarContainerAndroid*>(
-          Java_TabBase_getNativeInfoBarContainer(
+          Java_Tab_getNativeInfoBarContainer(
               env,
               weak_java_tab_.get(env).obj()));
   InfoBarService* new_infobar_service = new_contents ?
       InfoBarService::FromWebContents(new_contents) : NULL;
   infobar_container->ChangeInfoBarService(new_infobar_service);
 
-  Java_TabBase_swapWebContents(
+  Java_Tab_swapWebContents(
       env,
       weak_java_tab_.get(env).obj(),
       reinterpret_cast<intptr_t>(new_contents),
       did_start_load,
       did_finish_load);
 }
 
 void TabAndroid::Observe(int type,
                          const content::NotificationSource& source,
                          const content::NotificationDetails& details) {
@@ skipping 13 matching lines @@
           num_popups = popup_blocker_helper->GetBlockedPopupsCount();
 
         if (num_popups > 0)
           PopupBlockedInfoBarDelegate::Create(web_contents(), num_popups);
 
         settings->SetBlockageHasBeenIndicated(CONTENT_SETTINGS_TYPE_POPUPS);
       }
       break;
     }
     case chrome::NOTIFICATION_FAVICON_UPDATED:
-      Java_TabBase_onFaviconUpdated(env, weak_java_tab_.get(env).obj());
+      Java_Tab_onFaviconUpdated(env, weak_java_tab_.get(env).obj());
       break;
     case content::NOTIFICATION_NAV_ENTRY_CHANGED:
-      Java_TabBase_onNavEntryChanged(env, weak_java_tab_.get(env).obj());
+      Java_Tab_onNavEntryChanged(env, weak_java_tab_.get(env).obj());
       break;
     default:
       NOTREACHED() << "Unexpected notification " << type;
       break;
   }
 }
 
 void TabAndroid::Destroy(JNIEnv* env, jobject obj) {
   delete this;
 }
@@ skipping 145 matching lines @@
 
 static void Init(JNIEnv* env, jobject obj) {
   TRACE_EVENT0("native", "TabAndroid::Init");
   // This will automatically bind to the Java object and pass ownership there.
   new TabAndroid(env, obj);
 }
 
 bool TabAndroid::RegisterTabAndroid(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }