Source/WebKit/android/nav/WebView.cpp

   1 /*
   2  * Copyright 2007, The Android Open Source Project
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *  * Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  *  * Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #define LOG_TAG "webviewglue"
  27
  28 #include "config.h"
  29
  30 #include "AndroidAnimation.h"
  31 #include "AndroidLog.h"
  32 #include "BaseLayerAndroid.h"
  33 #include "CachedFrame.h"
  34 #include "CachedNode.h"
  35 #include "CachedRoot.h"
  36 #include "DrawExtra.h"
  37 #include "FindCanvas.h"
  38 #include "Frame.h"
  39 #include "GraphicsJNI.h"
  40 #include "HTMLInputElement.h"
  41 #include "IntPoint.h"
  42 #include "IntRect.h"
  43 #include "LayerAndroid.h"
  44 #include "Node.h"
  45 #include "utils/Functor.h"
  46 #include "private/hwui/DrawGlInfo.h"
  47 #include "PlatformGraphicsContext.h"
  48 #include "PlatformString.h"
  49 #include "ScrollableLayerAndroid.h"
  50 #include "SelectText.h"
  51 #include "SkCanvas.h"
  52 #include "SkDumpCanvas.h"
  53 #include "SkPicture.h"
  54 #include "SkRect.h"
  55 #include "SkTime.h"
  56 #ifdef ANDROID_INSTRUMENT
  57 #include "TimeCounter.h"
  58 #endif
  59 #include "TilesManager.h"
  60 #include "WebCoreJni.h"
  61 #include "WebRequestContext.h"
  62 #include "WebViewCore.h"
  63 #include "android_graphics.h"
  64
  65 #ifdef GET_NATIVE_VIEW
  66 #undef GET_NATIVE_VIEW
  67 #endif
  68
  69 #define GET_NATIVE_VIEW(env, obj) ((WebView*)env->GetIntField(obj, gWebViewField))
  70
  71 #include <JNIUtility.h>
  72 #include <JNIHelp.h>
  73 #include <jni.h>
  74 #include <ui/KeycodeLabels.h>
  75 #include <wtf/text/AtomicString.h>
  76 #include <wtf/text/CString.h>
  77
  78 // Free as much as we possible can
  79 #define TRIM_MEMORY_COMPLETE 80
  80 // Free a lot (all textures gone)
  81 #define TRIM_MEMORY_MODERATE 60
  82 // More moderate free (keep bare minimum to restore quickly-ish - possibly clear all textures)
  83 #define TRIM_MEMORY_BACKGROUND 40
  84 // Moderate free (clear cached tiles, keep visible ones)
  85 #define TRIM_MEMORY_UI_HIDDEN 20
  86 // Duration to show the pressed cursor ring
  87 #define PRESSED_STATE_DURATION 400
  88
  89 namespace android {
  90
  91 static jfieldID gWebViewField;
  92
  93 //-------------------------------------
  94
  95 static jmethodID GetJMethod(JNIEnv* env, jclass clazz, const char name[], const char signature[])
  96 {
  97     jmethodID m = env->GetMethodID(clazz, name, signature);
  98     LOG_ASSERT(m, "Could not find method %s", name);
  99     return m;
 100 }
 101
 102 //-------------------------------------
 103 // This class provides JNI for making calls into native code from the UI side
 104 // of the multi-threaded WebView.
 105 class WebView
 106 {
 107 public:
 108 enum FrameCachePermission {
 109     DontAllowNewer,
 110     AllowNewer
 111 };
 112
 113 enum DrawExtras { // keep this in sync with WebView.java
 114     DrawExtrasNone = 0,
 115     DrawExtrasFind = 1,
 116     DrawExtrasSelection = 2,
 117     DrawExtrasCursorRing = 3
 118 };
 119
 120 struct JavaGlue {
 121     jweak       m_obj;
 122     jmethodID   m_calcOurContentVisibleRectF;
 123     jmethodID   m_overrideLoading;
 124     jmethodID   m_scrollBy;
 125     jmethodID   m_sendMoveFocus;
 126     jmethodID   m_sendMoveMouse;
 127     jmethodID   m_sendMoveMouseIfLatest;
 128     jmethodID   m_sendMotionUp;
 129     jmethodID   m_domChangedFocus;
 130     jmethodID   m_getScaledMaxXScroll;
 131     jmethodID   m_getScaledMaxYScroll;
 132     jmethodID   m_getVisibleRect;
 133     jmethodID   m_rebuildWebTextView;
 134     jmethodID   m_viewInvalidate;
 135     jmethodID   m_viewInvalidateRect;
 136     jmethodID   m_postInvalidateDelayed;
 137     jmethodID   m_pageSwapCallback;
 138     jmethodID   m_inFullScreenMode;
 139     jfieldID    m_rectLeft;
 140     jfieldID    m_rectTop;
 141     jmethodID   m_rectWidth;
 142     jmethodID   m_rectHeight;
 143     jfieldID    m_rectFLeft;
 144     jfieldID    m_rectFTop;
 145     jmethodID   m_rectFWidth;
 146     jmethodID   m_rectFHeight;
 147     jmethodID   m_getTextHandleScale;
 148     AutoJObject object(JNIEnv* env) {
 149         return getRealObject(env, m_obj);
 150     }
 151 } m_javaGlue;
 152
 153 WebView(JNIEnv* env, jobject javaWebView, int viewImpl, WTF::String drawableDir) :
 154     m_ring((WebViewCore*) viewImpl)
 155 {
 156     jclass clazz = env->FindClass("android/webkit/WebView");
 157  //   m_javaGlue = new JavaGlue;
 158     m_javaGlue.m_obj = env->NewWeakGlobalRef(javaWebView);
 159     m_javaGlue.m_scrollBy = GetJMethod(env, clazz, "setContentScrollBy", "(IIZ)Z");
 160     m_javaGlue.m_calcOurContentVisibleRectF = GetJMethod(env, clazz, "calcOurContentVisibleRectF", "(Landroid/graphics/RectF;)V");
 161     m_javaGlue.m_overrideLoading = GetJMethod(env, clazz, "overrideLoading", "(Ljava/lang/String;)V");
 162     m_javaGlue.m_sendMoveFocus = GetJMethod(env, clazz, "sendMoveFocus", "(II)V");
 163     m_javaGlue.m_sendMoveMouse = GetJMethod(env, clazz, "sendMoveMouse", "(IIII)V");
 164     m_javaGlue.m_sendMoveMouseIfLatest = GetJMethod(env, clazz, "sendMoveMouseIfLatest", "(ZZ)V");
 165     m_javaGlue.m_sendMotionUp = GetJMethod(env, clazz, "sendMotionUp", "(IIIII)V");
 166     m_javaGlue.m_domChangedFocus = GetJMethod(env, clazz, "domChangedFocus", "()V");
 167     m_javaGlue.m_getScaledMaxXScroll = GetJMethod(env, clazz, "getScaledMaxXScroll", "()I");
 168     m_javaGlue.m_getScaledMaxYScroll = GetJMethod(env, clazz, "getScaledMaxYScroll", "()I");
 169     m_javaGlue.m_getVisibleRect = GetJMethod(env, clazz, "sendOurVisibleRect", "()Landroid/graphics/Rect;");
 170     m_javaGlue.m_rebuildWebTextView = GetJMethod(env, clazz, "rebuildWebTextView", "()V");
 171     m_javaGlue.m_viewInvalidate = GetJMethod(env, clazz, "viewInvalidate", "()V");
 172     m_javaGlue.m_viewInvalidateRect = GetJMethod(env, clazz, "viewInvalidate", "(IIII)V");
 173     m_javaGlue.m_postInvalidateDelayed = GetJMethod(env, clazz,
 174         "viewInvalidateDelayed", "(JIIII)V");
 175     m_javaGlue.m_pageSwapCallback = GetJMethod(env, clazz, "pageSwapCallback", "()V");
 176     m_javaGlue.m_inFullScreenMode = GetJMethod(env, clazz, "inFullScreenMode", "()Z");
 177     m_javaGlue.m_getTextHandleScale = GetJMethod(env, clazz, "getTextHandleScale", "()F");
 178     env->DeleteLocalRef(clazz);
 179
 180     jclass rectClass = env->FindClass("android/graphics/Rect");
 181     LOG_ASSERT(rectClass, "Could not find Rect class");
 182     m_javaGlue.m_rectLeft = env->GetFieldID(rectClass, "left", "I");
 183     m_javaGlue.m_rectTop = env->GetFieldID(rectClass, "top", "I");
 184     m_javaGlue.m_rectWidth = GetJMethod(env, rectClass, "width", "()I");
 185     m_javaGlue.m_rectHeight = GetJMethod(env, rectClass, "height", "()I");
 186     env->DeleteLocalRef(rectClass);
 187
 188     jclass rectClassF = env->FindClass("android/graphics/RectF");
 189     LOG_ASSERT(rectClassF, "Could not find RectF class");
 190     m_javaGlue.m_rectFLeft = env->GetFieldID(rectClassF, "left", "F");
 191     m_javaGlue.m_rectFTop = env->GetFieldID(rectClassF, "top", "F");
 192     m_javaGlue.m_rectFWidth = GetJMethod(env, rectClassF, "width", "()F");
 193     m_javaGlue.m_rectFHeight = GetJMethod(env, rectClassF, "height", "()F");
 194     env->DeleteLocalRef(rectClassF);
 195
 196     env->SetIntField(javaWebView, gWebViewField, (jint)this);
 197     m_viewImpl = (WebViewCore*) viewImpl;
 198     m_frameCacheUI = 0;
 199     m_navPictureUI = 0;
 200     m_generation = 0;
 201     m_heightCanMeasure = false;
 202     m_lastDx = 0;
 203     m_lastDxTime = 0;
 204     m_ringAnimationEnd = 0;
 205     m_baseLayer = 0;
 206     m_glDrawFunctor = 0;
 207     m_buttonSkin = drawableDir.isEmpty() ? 0 : new RenderSkinButton(drawableDir);
 208 #if USE(ACCELERATED_COMPOSITING)
 209     m_glWebViewState = 0;
 210     m_pageSwapCallbackRegistered = false;
 211 #endif
 212 }
 213
 214 ~WebView()
 215 {
 216     if (m_javaGlue.m_obj)
 217     {
 218         JNIEnv* env = JSC::Bindings::getJNIEnv();
 219         env->DeleteWeakGlobalRef(m_javaGlue.m_obj);
 220         m_javaGlue.m_obj = 0;
 221     }
 222 #if USE(ACCELERATED_COMPOSITING)
 223     // We must remove the m_glWebViewState prior to deleting m_baseLayer. If we
 224     // do not remove it here, we risk having BaseTiles trying to paint using a
 225     // deallocated base layer.
 226     stopGL();
 227 #endif
 228     delete m_frameCacheUI;
 229     delete m_navPictureUI;
 230     SkSafeUnref(m_baseLayer);
 231     delete m_glDrawFunctor;
 232     delete m_buttonSkin;
 233 }
 234
 235 void stopGL()
 236 {
 237 #if USE(ACCELERATED_COMPOSITING)
 238     delete m_glWebViewState;
 239     m_glWebViewState = 0;
 240 #endif
 241 }
 242
 243 WebViewCore* getWebViewCore() const {
 244     return m_viewImpl;
 245 }
 246
 247 float getTextHandleScale()
 248 {
 249     LOG_ASSERT(m_javaGlue.m_obj, "A java object was not associated with this native WebView!");
 250     JNIEnv* env = JSC::Bindings::getJNIEnv();
 251     AutoJObject javaObject = m_javaGlue.object(env);
 252     if (!javaObject.get())
 253         return 0;
 254     float result = env->CallFloatMethod(javaObject.get(), m_javaGlue.m_getTextHandleScale);
 255     checkException(env);
 256     return result;
 257 }
 258
 259 void updateSelectionHandles()
 260 {
 261     if (!m_baseLayer)
 262         return;
 263     // Adjust for device density & scale
 264     m_selectText.updateHandleScale(getTextHandleScale());
 265 }
 266
 267 // removes the cursor altogether (e.g., when going to a new page)
 268 void clearCursor()
 269 {
 270     CachedRoot* root = getFrameCache(AllowNewer);
 271     if (!root)
 272         return;
 273     DBG_NAV_LOG("");
 274     m_viewImpl->m_hasCursorBounds = false;
 275     root->clearCursor();
 276     viewInvalidate();
 277 }
 278
 279 // leaves the cursor where it is, but suppresses drawing it
 280 void hideCursor()
 281 {
 282     CachedRoot* root = getFrameCache(AllowNewer);
 283     if (!root)
 284         return;
 285     DBG_NAV_LOG("");
 286     hideCursor(root);
 287     viewInvalidate();
 288 }
 289
 290 void hideCursor(CachedRoot* root)
 291 {
 292     DBG_NAV_LOG("inner");
 293     m_viewImpl->m_hasCursorBounds = false;
 294     root->hideCursor();
 295 }
 296
 297 #if DUMP_NAV_CACHE
 298 void debugDump()
 299 {
 300     CachedRoot* root = getFrameCache(DontAllowNewer);
 301     if (root)
 302         root->mDebug.print();
 303 }
 304 #endif
 305
 306 // Traverse our stored array of buttons that are in our picture, and update
 307 // their subpictures according to their current state.
 308 // Called from the UI thread.  This is the one place in the UI thread where we
 309 // access the buttons stored in the WebCore thread.
 310 // hasFocus keeps track of whether the WebView has focus && windowFocus.
 311 // If not, we do not want to draw the button in a selected or pressed state
 312 void nativeRecordButtons(bool hasFocus, bool pressed, bool invalidate)
 313 {
 314     bool cursorIsOnButton = false;
 315     const CachedFrame* cachedFrame;
 316     const CachedNode* cachedCursor = 0;
 317     // Lock the mutex, since we now share with the WebCore thread.
 318     m_viewImpl->gButtonMutex.lock();
 319     if (m_viewImpl->m_buttons.size() && m_buttonSkin) {
 320         // FIXME: In a future change, we should keep track of whether the selection
 321         // has changed to short circuit (note that we would still need to update
 322         // if we received new buttons from the WebCore thread).
 323         WebCore::Node* cursor = 0;
 324         CachedRoot* root = getFrameCache(DontAllowNewer);
 325         if (root) {
 326             cachedCursor = root->currentCursor(&cachedFrame);
 327             if (cachedCursor)
 328                 cursor = (WebCore::Node*) cachedCursor->nodePointer();
 329         }
 330
 331         // Traverse the array, and update each button, depending on whether it
 332         // is selected.
 333         Container* end = m_viewImpl->m_buttons.end();
 334         for (Container* ptr = m_viewImpl->m_buttons.begin(); ptr != end; ptr++) {
 335             RenderSkinAndroid::State state = RenderSkinAndroid::kNormal;
 336             if (ptr->matches(cursor)) {
 337                 cursorIsOnButton = true;
 338                 // If the WebView is out of focus/window focus, set the state to
 339                 // normal, but still keep track of the fact that the selected is a
 340                 // button
 341                 if (hasFocus) {
 342                     if (pressed || m_ring.m_isPressed)
 343                         state = RenderSkinAndroid::kPressed;
 344                     else if (SkTime::GetMSecs() < m_ringAnimationEnd)
 345                         state = RenderSkinAndroid::kFocused;
 346                 }
 347             }
 348             ptr->updateFocusState(state, m_buttonSkin);
 349         }
 350     }
 351     m_viewImpl->gButtonMutex.unlock();
 352     if (invalidate && cachedCursor && cursorIsOnButton) {
 353         const WebCore::IntRect& b = cachedCursor->bounds(cachedFrame);
 354         viewInvalidateRect(b.x(), b.y(), b.maxX(), b.maxY());
 355     }
 356 }
 357
 358 void scrollToCurrentMatch()
 359 {
 360     if (!m_findOnPage.currentMatchIsInLayer()) {
 361         scrollRectOnScreen(m_findOnPage.currentMatchBounds());
 362         return;
 363     }
 364
 365     SkRect matchBounds = m_findOnPage.currentMatchBounds();
 366     LayerAndroid* rootLayer = getFrameCache(DontAllowNewer)->rootLayer();
 367     Layer* layerContainingMatch = rootLayer->findById(m_findOnPage.currentMatchLayerId());
 368     ASSERT(layerContainingMatch);
 369
 370     // If the match is in a fixed position layer, there's nothing to do.
 371     if (layerContainingMatch->shouldInheritFromRootTransform())
 372         return;
 373
 374     // If the match is in a scrollable layer or a descendant of such a layer,
 375     // there may be a range of of scroll configurations that will make the
 376     // current match visible. Our approach is the simplest possible. Starting at
 377     // the layer in which the match is found, we move up the layer tree,
 378     // scrolling any scrollable layers as little as possible to make sure that
 379     // the current match is in view. This approach has the disadvantage that we
 380     // may end up scrolling a larger number of elements than is necessary, which
 381     // may be visually jarring. However, minimising the number of layers
 382     // scrolled would complicate the code significantly.
 383
 384     bool didScrollLayer = false;
 385     for (Layer* layer = layerContainingMatch; layer; layer = layer->getParent()) {
 386         ASSERT(layer->getParent() || layer == rootLayer);
 387
 388         if (layer->contentIsScrollable()) {
 389             // Convert the match location to layer's local space and scroll it.
 390             // Repeatedly calling Layer::localToAncestor() is inefficient as
 391             // each call repeats part of the calculation. It would be more
 392             // efficient to maintain the transform here and update it on each
 393             // iteration, but that would mean duplicating logic from
 394             // Layer::localToAncestor() and would complicate things.
 395             SkMatrix transform;
 396             layerContainingMatch->localToAncestor(layer, &transform);
 397             SkRect transformedMatchBounds;
 398             transform.mapRect(&transformedMatchBounds, matchBounds);
 399             SkIRect roundedTransformedMatchBounds;
 400             transformedMatchBounds.roundOut(&roundedTransformedMatchBounds);
 401             // Only ScrollableLayerAndroid returns true for contentIsScrollable().
 402             didScrollLayer |= static_cast<ScrollableLayerAndroid*>(layer)->scrollRectIntoView(roundedTransformedMatchBounds);
 403         }
 404     }
 405     // Invalidate, as the call below to scroll the main page may be a no-op.
 406     if (didScrollLayer)
 407         viewInvalidate();
 408
 409     // Convert matchBounds to the global space so we can scroll the main page.
 410     SkMatrix transform;
 411     layerContainingMatch->localToGlobal(&transform);
 412     SkRect transformedMatchBounds;
 413     transform.mapRect(&transformedMatchBounds, matchBounds);
 414     SkIRect roundedTransformedMatchBounds;
 415     transformedMatchBounds.roundOut(&roundedTransformedMatchBounds);
 416     scrollRectOnScreen(roundedTransformedMatchBounds);
 417 }
 418
 419 void scrollRectOnScreen(const IntRect& rect)
 420 {
 421     if (rect.isEmpty())
 422         return;
 423     SkRect visible = SkRect::MakeEmpty();
 424     calcOurContentVisibleRect(&visible);
 425     int dx = 0;
 426     int left = rect.x();
 427     int right = rect.maxX();
 428     if (left < visible.fLeft) {
 429         dx = left - visible.fLeft;
 430     // Only scroll right if the entire width can fit on screen.
 431     } else if (right > visible.fRight && right - left < visible.width()) {
 432         dx = right - visible.fRight;
 433     }
 434     int dy = 0;
 435     int top = rect.y();
 436     int bottom = rect.maxY();
 437     if (top < visible.fTop) {
 438         dy = top - visible.fTop;
 439     // Only scroll down if the entire height can fit on screen
 440     } else if (bottom > visible.fBottom && bottom - top < visible.height()) {
 441         dy = bottom - visible.fBottom;
 442     }
 443     if ((dx|dy) == 0 || !scrollBy(dx, dy))
 444         return;
 445     viewInvalidate();
 446 }
 447
 448 void calcOurContentVisibleRect(SkRect* r)
 449 {
 450     JNIEnv* env = JSC::Bindings::getJNIEnv();
 451     AutoJObject javaObject = m_javaGlue.object(env);
 452     if (!javaObject.get())
 453         return;
 454     jclass rectClass = env->FindClass("android/graphics/RectF");
 455     jmethodID init = env->GetMethodID(rectClass, "<init>", "(FFFF)V");
 456     jobject jRect = env->NewObject(rectClass, init, 0, 0, 0, 0);
 457     env->CallVoidMethod(javaObject.get(), m_javaGlue.m_calcOurContentVisibleRectF, jRect);
 458     r->fLeft = env->GetFloatField(jRect, m_javaGlue.m_rectFLeft);
 459     r->fTop = env->GetFloatField(jRect, m_javaGlue.m_rectFTop);
 460     r->fRight = r->fLeft + env->CallFloatMethod(jRect, m_javaGlue.m_rectFWidth);
 461     r->fBottom = r->fTop + env->CallFloatMethod(jRect, m_javaGlue.m_rectFHeight);
 462     env->DeleteLocalRef(rectClass);
 463     env->DeleteLocalRef(jRect);
 464     checkException(env);
 465 }
 466
 467 void resetCursorRing()
 468 {
 469     m_ringAnimationEnd = 0;
 470     m_viewImpl->m_hasCursorBounds = false;
 471 }
 472
 473 bool drawCursorPreamble(CachedRoot* root)
 474 {
 475     if (!root) return false;
 476     const CachedFrame* frame;
 477     const CachedNode* node = root->currentCursor(&frame);
 478     if (!node) {
 479         DBG_NAV_LOGV("%s", "!node");
 480         resetCursorRing();
 481         return false;
 482     }
 483     m_ring.setIsButton(node);
 484     if (node->isHidden()) {
 485         DBG_NAV_LOG("node->isHidden()");
 486         m_viewImpl->m_hasCursorBounds = false;
 487         return false;
 488     }
 489 #if USE(ACCELERATED_COMPOSITING)
 490     if (node->isInLayer() && root->rootLayer()) {
 491         LayerAndroid* layer = root->rootLayer();
 492         SkRect visible;
 493         calcOurContentVisibleRect(&visible);
 494         layer->updateFixedLayersPositions(visible);
 495         layer->updatePositions();
 496     }
 497 #endif
 498     setVisibleRect(root);
 499     m_ring.m_root = root;
 500     m_ring.m_frame = frame;
 501     m_ring.m_node = node;
 502     SkMSec time = SkTime::GetMSecs();
 503     m_ring.m_isPressed = time < m_ringAnimationEnd
 504         && m_ringAnimationEnd != UINT_MAX;
 505     return true;
 506 }
 507
 508 void drawCursorPostamble()
 509 {
 510     if (m_ringAnimationEnd == UINT_MAX)
 511         return;
 512     SkMSec time = SkTime::GetMSecs();
 513     if (time < m_ringAnimationEnd) {
 514         // views assume that inval bounds coordinates are non-negative
 515         WebCore::IntRect invalBounds(0, 0, INT_MAX, INT_MAX);
 516         invalBounds.intersect(m_ring.m_absBounds);
 517         postInvalidateDelayed(m_ringAnimationEnd - time, invalBounds);
 518     } else {
 519         hideCursor(const_cast<CachedRoot*>(m_ring.m_root));
 520     }
 521 }
 522
 523 bool drawGL(WebCore::IntRect& viewRect, WebCore::IntRect* invalRect, WebCore::IntRect& webViewRect,
 524             int titleBarHeight, WebCore::IntRect& clip, float scale, int extras)
 525 {
 526 #if USE(ACCELERATED_COMPOSITING)
 527     if (!m_baseLayer || inFullScreenMode())
 528         return false;
 529
 530     if (!m_glWebViewState) {
 531         m_glWebViewState = new GLWebViewState(&m_viewImpl->gButtonMutex);
 532         m_glWebViewState->glExtras()->setCursorRingExtra(&m_ring);
 533         m_glWebViewState->glExtras()->setFindOnPageExtra(&m_findOnPage);
 534         if (m_baseLayer->content()) {
 535             SkRegion region;
 536             SkIRect rect;
 537             rect.set(0, 0, m_baseLayer->content()->width(), m_baseLayer->content()->height());
 538             region.setRect(rect);
 539             m_glWebViewState->setBaseLayer(m_baseLayer, region, false, true);
 540         }
 541     }
 542
 543     CachedRoot* root = getFrameCache(AllowNewer);
 544     if (!root) {
 545         DBG_NAV_LOG("!root");
 546         if (extras == DrawExtrasCursorRing)
 547             resetCursorRing();
 548     }
 549     DrawExtra* extra = 0;
 550     switch (extras) {
 551         case DrawExtrasFind:
 552             extra = &m_findOnPage;
 553             break;
 554         case DrawExtrasSelection:
 555             // This will involve a JNI call, but under normal circumstances we will
 556             // not hit this anyway. Only if USE_JAVA_TEXT_SELECTION is disabled
 557             // in WebView.java will we hit this (so really debug only)
 558             updateSelectionHandles();
 559             extra = &m_selectText;
 560             break;
 561         case DrawExtrasCursorRing:
 562             if (drawCursorPreamble(root) && m_ring.setup()) {
 563                 if (m_ring.m_isPressed || m_ringAnimationEnd == UINT_MAX)
 564                     extra = &m_ring;
 565                 drawCursorPostamble();
 566             }
 567             break;
 568         default:
 569             ;
 570     }
 571
 572     unsigned int pic = m_glWebViewState->currentPictureCounter();
 573     m_glWebViewState->glExtras()->setDrawExtra(extra);
 574
 575     SkRect visibleRect;
 576     calcOurContentVisibleRect(&visibleRect);
 577     // Make sure we have valid coordinates. We might not have valid coords
 578     // if the zoom manager is still initializing. We will be redrawn
 579     // once the correct scale is set
 580     if (!visibleRect.hasValidCoordinates())
 581         return false;
 582     bool pagesSwapped = false;
 583     bool ret = m_glWebViewState->drawGL(viewRect, visibleRect, invalRect,
 584                                         webViewRect, titleBarHeight, clip, scale,
 585                                         &pagesSwapped);
 586     if (m_pageSwapCallbackRegistered && pagesSwapped) {
 587         m_pageSwapCallbackRegistered = false;
 588         LOG_ASSERT(m_javaGlue.m_obj, "A java object was not associated with this native WebView!");
 589         JNIEnv* env = JSC::Bindings::getJNIEnv();
 590         AutoJObject javaObject = m_javaGlue.object(env);
 591         if (javaObject.get()) {
 592             env->CallVoidMethod(javaObject.get(), m_javaGlue.m_pageSwapCallback);
 593             checkException(env);
 594         }
 595     }
 596     if (ret || m_glWebViewState->currentPictureCounter() != pic)
 597         return true;
 598 #endif
 599     return false;
 600 }
 601
 602 PictureSet* draw(SkCanvas* canvas, SkColor bgColor, int extras, bool split)
 603 {
 604     PictureSet* ret = 0;
 605     if (!m_baseLayer) {
 606         canvas->drawColor(bgColor);
 607         return ret;
 608     }
 609
 610     // draw the content of the base layer first
 611     PictureSet* content = m_baseLayer->content();
 612     int sc = canvas->save(SkCanvas::kClip_SaveFlag);
 613     canvas->clipRect(SkRect::MakeLTRB(0, 0, content->width(),
 614                 content->height()), SkRegion::kDifference_Op);
 615     canvas->drawColor(bgColor);
 616     canvas->restoreToCount(sc);
 617     if (content->draw(canvas))
 618         ret = split ? new PictureSet(*content) : 0;
 619
 620     CachedRoot* root = getFrameCache(AllowNewer);
 621     if (!root) {
 622         DBG_NAV_LOG("!root");
 623         if (extras == DrawExtrasCursorRing)
 624             resetCursorRing();
 625     }
 626     LayerAndroid mainPicture(m_navPictureUI);
 627     DrawExtra* extra = 0;
 628     switch (extras) {
 629         case DrawExtrasFind:
 630             extra = &m_findOnPage;
 631             break;
 632         case DrawExtrasSelection:
 633             // This will involve a JNI call, but under normal circumstances we will
 634             // not hit this anyway. Only if USE_JAVA_TEXT_SELECTION is disabled
 635             // in WebView.java will we hit this (so really debug only)
 636             updateSelectionHandles();
 637             extra = &m_selectText;
 638             break;
 639         case DrawExtrasCursorRing:
 640             if (drawCursorPreamble(root) && m_ring.setup()) {
 641                 if (!m_ring.m_isButton)
 642                     extra = &m_ring;
 643                 drawCursorPostamble();
 644             }
 645             break;
 646         default:
 647             ;
 648     }
 649 #if USE(ACCELERATED_COMPOSITING)
 650     LayerAndroid* compositeLayer = compositeRoot();
 651     if (compositeLayer) {
 652         SkRect visible;
 653         calcOurContentVisibleRect(&visible);
 654         // call this to be sure we've adjusted for any scrolling or animations
 655         // before we actually draw
 656         compositeLayer->updateFixedLayersPositions(visible);
 657         compositeLayer->updatePositions();
 658         // We have to set the canvas' matrix on the base layer
 659         // (to have fixed layers work as intended)
 660         SkAutoCanvasRestore restore(canvas, true);
 661         m_baseLayer->setMatrix(canvas->getTotalMatrix());
 662         canvas->resetMatrix();
 663         m_baseLayer->draw(canvas);
 664     }
 665 #endif
 666     if (extra) {
 667         IntRect dummy; // inval area, unused for now
 668         extra->draw(canvas, &mainPicture, &dummy);
 669     }
 670     return ret;
 671 }
 672
 673
 674 bool cursorIsTextInput(FrameCachePermission allowNewer)
 675 {
 676     CachedRoot* root = getFrameCache(allowNewer);
 677     if (!root) {
 678         DBG_NAV_LOG("!root");
 679         return false;
 680     }
 681     const CachedNode* cursor = root->currentCursor();
 682     if (!cursor) {
 683         DBG_NAV_LOG("!cursor");
 684         return false;
 685     }
 686     DBG_NAV_LOGD("%s", cursor->isTextInput() ? "true" : "false");
 687     return cursor->isTextInput();
 688 }
 689
 690 void cursorRingBounds(WebCore::IntRect* bounds)
 691 {
 692     DBG_NAV_LOGD("%s", "");
 693     CachedRoot* root = getFrameCache(DontAllowNewer);
 694     if (root) {
 695         const CachedFrame* cachedFrame;
 696         const CachedNode* cachedNode = root->currentCursor(&cachedFrame);
 697         if (cachedNode) {
 698             *bounds = cachedNode->cursorRingBounds(cachedFrame);
 699             DBG_NAV_LOGD("bounds={%d,%d,%d,%d}", bounds->x(), bounds->y(),
 700                 bounds->width(), bounds->height());
 701             return;
 702         }
 703     }
 704     *bounds = WebCore::IntRect(0, 0, 0, 0);
 705 }
 706
 707 void fixCursor()
 708 {
 709     m_viewImpl->gCursorBoundsMutex.lock();
 710     bool hasCursorBounds = m_viewImpl->m_hasCursorBounds;
 711     IntRect bounds = m_viewImpl->m_cursorBounds;
 712     m_viewImpl->gCursorBoundsMutex.unlock();
 713     if (!hasCursorBounds)
 714         return;
 715     int x, y;
 716     const CachedFrame* frame;
 717     const CachedNode* node = m_frameCacheUI->findAt(bounds, &frame, &x, &y, true);
 718     if (!node)
 719         return;
 720     // require that node have approximately the same bounds (+/- 4) and the same
 721     // center (+/- 2)
 722     IntPoint oldCenter = IntPoint(bounds.x() + (bounds.width() >> 1),
 723         bounds.y() + (bounds.height() >> 1));
 724     IntRect newBounds = node->bounds(frame);
 725     IntPoint newCenter = IntPoint(newBounds.x() + (newBounds.width() >> 1),
 726         newBounds.y() + (newBounds.height() >> 1));
 727     DBG_NAV_LOGD("oldCenter=(%d,%d) newCenter=(%d,%d)"
 728         " bounds=(%d,%d,w=%d,h=%d) newBounds=(%d,%d,w=%d,h=%d)",
 729         oldCenter.x(), oldCenter.y(), newCenter.x(), newCenter.y(),
 730         bounds.x(), bounds.y(), bounds.width(), bounds.height(),
 731         newBounds.x(), newBounds.y(), newBounds.width(), newBounds.height());
 732     if (abs(oldCenter.x() - newCenter.x()) > 2)
 733         return;
 734     if (abs(oldCenter.y() - newCenter.y()) > 2)
 735         return;
 736     if (abs(bounds.x() - newBounds.x()) > 4)
 737         return;
 738     if (abs(bounds.y() - newBounds.y()) > 4)
 739         return;
 740     if (abs(bounds.maxX() - newBounds.maxX()) > 4)
 741         return;
 742     if (abs(bounds.maxY() - newBounds.maxY()) > 4)
 743         return;
 744     DBG_NAV_LOGD("node=%p frame=%p x=%d y=%d bounds=(%d,%d,w=%d,h=%d)",
 745         node, frame, x, y, bounds.x(), bounds.y(), bounds.width(),
 746         bounds.height());
 747     m_frameCacheUI->setCursor(const_cast<CachedFrame*>(frame),
 748         const_cast<CachedNode*>(node));
 749 }
 750
 751 CachedRoot* getFrameCache(FrameCachePermission allowNewer)
 752 {
 753     if (!m_viewImpl->m_updatedFrameCache) {
 754         DBG_NAV_LOGV("%s", "!m_viewImpl->m_updatedFrameCache");
 755         return m_frameCacheUI;
 756     }
 757     if (allowNewer == DontAllowNewer && m_viewImpl->m_lastGeneration < m_generation) {
 758         DBG_NAV_LOGD("allowNewer==DontAllowNewer m_viewImpl->m_lastGeneration=%d"
 759             " < m_generation=%d", m_viewImpl->m_lastGeneration, m_generation);
 760         return m_frameCacheUI;
 761     }
 762     DBG_NAV_LOGD("%s", "m_viewImpl->m_updatedFrameCache == true");
 763     const CachedFrame* oldCursorFrame;
 764     const CachedNode* oldCursorNode = m_frameCacheUI ?
 765         m_frameCacheUI->currentCursor(&oldCursorFrame) : 0;
 766 #if USE(ACCELERATED_COMPOSITING)
 767     int layerId = -1;
 768     if (oldCursorNode && oldCursorNode->isInLayer()) {
 769         const LayerAndroid* cursorLayer = oldCursorFrame->layer(oldCursorNode)
 770             ->layer(m_frameCacheUI->rootLayer());
 771         if (cursorLayer)
 772             layerId = cursorLayer->uniqueId();
 773     }
 774 #endif
 775     // get id from old layer and use to find new layer
 776     bool oldFocusIsTextInput = false;
 777     void* oldFocusNodePointer = 0;
 778     if (m_frameCacheUI) {
 779         const CachedNode* oldFocus = m_frameCacheUI->currentFocus();
 780         if (oldFocus) {
 781             oldFocusIsTextInput = oldFocus->isTextInput();
 782             oldFocusNodePointer = oldFocus->nodePointer();
 783         }
 784     }
 785     m_viewImpl->gFrameCacheMutex.lock();
 786     delete m_frameCacheUI;
 787     SkSafeUnref(m_navPictureUI);
 788     m_viewImpl->m_updatedFrameCache = false;
 789     m_frameCacheUI = m_viewImpl->m_frameCacheKit;
 790     m_navPictureUI = m_viewImpl->m_navPictureKit;
 791     m_viewImpl->m_frameCacheKit = 0;
 792     m_viewImpl->m_navPictureKit = 0;
 793     m_viewImpl->gFrameCacheMutex.unlock();
 794     if (m_frameCacheUI)
 795         m_frameCacheUI->setRootLayer(compositeRoot());
 796 #if USE(ACCELERATED_COMPOSITING)
 797     if (layerId >= 0) {
 798         SkRect visible;
 799         calcOurContentVisibleRect(&visible);
 800         LayerAndroid* layer = const_cast<LayerAndroid*>(
 801                                                 m_frameCacheUI->rootLayer());
 802         if (layer) {
 803             layer->updateFixedLayersPositions(visible);
 804             layer->updatePositions();
 805         }
 806     }
 807 #endif
 808     fixCursor();
 809     if (oldFocusIsTextInput) {
 810         const CachedNode* newFocus = m_frameCacheUI->currentFocus();
 811         if (newFocus && oldFocusNodePointer != newFocus->nodePointer()
 812                 && newFocus->isTextInput()
 813                 && newFocus != m_frameCacheUI->currentCursor()) {
 814             // The focus has changed.  We may need to update things.
 815             LOG_ASSERT(m_javaGlue.m_obj, "A java object was not associated with this native WebView!");
 816             JNIEnv* env = JSC::Bindings::getJNIEnv();
 817             AutoJObject javaObject = m_javaGlue.object(env);
 818             if (javaObject.get()) {
 819                 env->CallVoidMethod(javaObject.get(), m_javaGlue.m_domChangedFocus);
 820                 checkException(env);
 821             }
 822         }
 823     }
 824     if (oldCursorNode && (!m_frameCacheUI || !m_frameCacheUI->currentCursor()))
 825         viewInvalidate(); // redraw in case cursor ring is still visible
 826     return m_frameCacheUI;
 827 }
 828
 829 int getScaledMaxXScroll()
 830 {
 831     LOG_ASSERT(m_javaGlue.m_obj, "A java object was not associated with this native WebView!");
 832     JNIEnv* env = JSC::Bindings::getJNIEnv();
 833     AutoJObject javaObject = m_javaGlue.object(env);
 834     if (!javaObject.get())
 835         return 0;
 836     int result = env->CallIntMethod(javaObject.get(), m_javaGlue.m_getScaledMaxXScroll);
 837     checkException(env);
 838     return result;
 839 }
 840
 841 int getScaledMaxYScroll()
 842 {
 843     LOG_ASSERT(m_javaGlue.m_obj, "A java object was not associated with this native WebView!");
 844     JNIEnv* env = JSC::Bindings::getJNIEnv();
 845     AutoJObject javaObject = m_javaGlue.object(env);
 846     if (!javaObject.get())
 847         return 0;
 848     int result = env->CallIntMethod(javaObject.get(), m_javaGlue.m_getScaledMaxYScroll);
 849     checkException(env);
 850     return result;
 851 }
 852
 853 IntRect getVisibleRect()
 854 {
 855     IntRect rect;
 856     LOG_ASSERT(m_javaGlue.m_obj, "A java object was not associated with this native WebView!");
 857     JNIEnv* env = JSC::Bindings::getJNIEnv();
 858     AutoJObject javaObject = m_javaGlue.object(env);
 859     if (!javaObject.get())
 860         return rect;
 861     jobject jRect = env->CallObjectMethod(javaObject.get(), m_javaGlue.m_getVisibleRect);
 862     checkException(env);
 863     rect.setX(env->GetIntField(jRect, m_javaGlue.m_rectLeft));
 864     checkException(env);
 865     rect.setY(env->GetIntField(jRect, m_javaGlue.m_rectTop));
 866     checkException(env);
 867     rect.setWidth(env->CallIntMethod(jRect, m_javaGlue.m_rectWidth));
 868     checkException(env);
 869     rect.setHeight(env->CallIntMethod(jRect, m_javaGlue.m_rectHeight));
 870     checkException(env);
 871     env->DeleteLocalRef(jRect);
 872     checkException(env);
 873     return rect;
 874 }
 875
 876 static CachedFrame::Direction KeyToDirection(int32_t keyCode)
 877 {
 878     switch (keyCode) {
 879         case AKEYCODE_DPAD_RIGHT:
 880             DBG_NAV_LOGD("keyCode=%s", "right");
 881             return CachedFrame::RIGHT;
 882         case AKEYCODE_DPAD_LEFT:
 883             DBG_NAV_LOGD("keyCode=%s", "left");
 884             return CachedFrame::LEFT;
 885         case AKEYCODE_DPAD_DOWN:
 886             DBG_NAV_LOGD("keyCode=%s", "down");
 887             return CachedFrame::DOWN;
 888         case AKEYCODE_DPAD_UP:
 889             DBG_NAV_LOGD("keyCode=%s", "up");
 890             return CachedFrame::UP;
 891         default:
 892             DBG_NAV_LOGD("bad key %d sent", keyCode);
 893             return CachedFrame::UNINITIALIZED;
 894     }
 895 }
 896
 897 WTF::String imageURI(int x, int y)
 898 {
 899     const CachedRoot* root = getFrameCache(DontAllowNewer);
 900     return root ? root->imageURI(x, y) : WTF::String();
 901 }
 902
 903 bool cursorWantsKeyEvents()
 904 {
 905     const CachedRoot* root = getFrameCache(DontAllowNewer);
 906     if (root) {
 907         const CachedNode* focus = root->currentCursor();
 908         if (focus)
 909             return focus->wantsKeyEvents();
 910     }
 911     return false;
 912 }
 913
 914
 915 /* returns true if the key had no effect (neither scrolled nor changed cursor) */
 916 bool moveCursor(int keyCode, int count, bool ignoreScroll)
 917 {
 918     CachedRoot* root = getFrameCache(AllowNewer);
 919     if (!root) {
 920         DBG_NAV_LOG("!root");
 921         return true;
 922     }
 923
 924     m_viewImpl->m_moveGeneration++;
 925     CachedFrame::Direction direction = KeyToDirection(keyCode);
 926     const CachedFrame* cachedFrame, * oldFrame = 0;
 927     const CachedNode* cursor = root->currentCursor(&oldFrame);
 928     WebCore::IntPoint cursorLocation = root->cursorLocation();
 929     DBG_NAV_LOGD("old cursor %d (nativeNode=%p) cursorLocation={%d, %d}",
 930         cursor ? cursor->index() : 0,
 931         cursor ? cursor->nodePointer() : 0, cursorLocation.x(), cursorLocation.y());
 932     WebCore::IntRect visibleRect = setVisibleRect(root);
 933     int xMax = getScaledMaxXScroll();
 934     int yMax = getScaledMaxYScroll();
 935     root->setMaxScroll(xMax, yMax);
 936     const CachedNode* cachedNode = 0;
 937     int dx = 0;
 938     int dy = 0;
 939     int counter = count;
 940     while (--counter >= 0) {
 941         WebCore::IntPoint scroll = WebCore::IntPoint(0, 0);
 942         cachedNode = root->moveCursor(direction, &cachedFrame, &scroll);
 943         dx += scroll.x();
 944         dy += scroll.y();
 945     }
 946     DBG_NAV_LOGD("new cursor %d (nativeNode=%p) cursorLocation={%d, %d}"
 947         "bounds={%d,%d,w=%d,h=%d}", cachedNode ? cachedNode->index() : 0,
 948         cachedNode ? cachedNode->nodePointer() : 0,
 949             root->cursorLocation().x(), root->cursorLocation().y(),
 950             cachedNode ? cachedNode->bounds(cachedFrame).x() : 0,
 951             cachedNode ? cachedNode->bounds(cachedFrame).y() : 0,
 952             cachedNode ? cachedNode->bounds(cachedFrame).width() : 0,
 953             cachedNode ? cachedNode->bounds(cachedFrame).height() : 0);
 954     // If !m_heightCanMeasure (such as in the browser), we want to scroll no
 955     // matter what
 956     if (!ignoreScroll && (!m_heightCanMeasure ||
 957             !cachedNode ||
 958             (cursor && cursor->nodePointer() == cachedNode->nodePointer())))
 959     {
 960         if (count == 1 && dx != 0 && dy == 0 && -m_lastDx == dx &&
 961                 SkTime::GetMSecs() - m_lastDxTime < 1000)
 962             root->checkForJiggle(&dx);
 963         DBG_NAV_LOGD("scrollBy %d,%d", dx, dy);
 964         if ((dx | dy))
 965             this->scrollBy(dx, dy);
 966         m_lastDx = dx;
 967         m_lastDxTime = SkTime::GetMSecs();
 968     }
 969     bool result = false;
 970     if (cachedNode) {
 971         showCursorUntimed();
 972         m_viewImpl->updateCursorBounds(root, cachedFrame, cachedNode);
 973         root->setCursor(const_cast<CachedFrame*>(cachedFrame),
 974                 const_cast<CachedNode*>(cachedNode));
 975         const CachedNode* focus = root->currentFocus();
 976         bool clearTextEntry = cachedNode != focus && focus
 977                 && cachedNode->nodePointer() != focus->nodePointer() && focus->isTextInput();
 978         // Stop painting the caret if the old focus was a text input and so is the new cursor.
 979         bool stopPaintingCaret = clearTextEntry && cachedNode->wantsKeyEvents();
 980         sendMoveMouseIfLatest(clearTextEntry, stopPaintingCaret);
 981     } else {
 982         int docHeight = root->documentHeight();
 983         int docWidth = root->documentWidth();
 984         if (visibleRect.maxY() + dy > docHeight)
 985             dy = docHeight - visibleRect.maxY();
 986         else if (visibleRect.y() + dy < 0)
 987             dy = -visibleRect.y();
 988         if (visibleRect.maxX() + dx > docWidth)
 989             dx = docWidth - visibleRect.maxX();
 990         else if (visibleRect.x() < 0)
 991             dx = -visibleRect.x();
 992         result = direction == CachedFrame::LEFT ? dx >= 0 :
 993             direction == CachedFrame::RIGHT ? dx <= 0 :
 994             direction == CachedFrame::UP ? dy >= 0 : dy <= 0;
 995     }
 996     return result;
 997 }
 998
 999 void notifyProgressFinished()
1000 {
1001     DBG_NAV_LOGD("cursorIsTextInput=%d", cursorIsTextInput(DontAllowNewer));
1002     rebuildWebTextView();
1003 #if DEBUG_NAV_UI
1004     if (m_frameCacheUI) {
1005         const CachedNode* focus = m_frameCacheUI->currentFocus();
1006         DBG_NAV_LOGD("focus %d (nativeNode=%p)",
1007             focus ? focus->index() : 0,
1008             focus ? focus->nodePointer() : 0);
1009     }
1010 #endif
1011 }
1012
1013 const CachedNode* findAt(CachedRoot* root, const WebCore::IntRect& rect,
1014     const CachedFrame** framePtr, int* rxPtr, int* ryPtr)
1015 {
1016     *rxPtr = 0;
1017     *ryPtr = 0;
1018     *framePtr = 0;
1019     if (!root)
1020         return 0;
1021     setVisibleRect(root);
1022     return root->findAt(rect, framePtr, rxPtr, ryPtr, true);
1023 }
1024
1025 IntRect setVisibleRect(CachedRoot* root)
1026 {
1027     IntRect visibleRect = getVisibleRect();
1028     DBG_NAV_LOGD("getVisibleRect %d,%d,%d,%d",
1029         visibleRect.x(), visibleRect.y(), visibleRect.width(), visibleRect.height());
1030     root->setVisibleRect(visibleRect);
1031     return visibleRect;
1032 }
1033
1034 void selectBestAt(const WebCore::IntRect& rect)
1035 {
1036     const CachedFrame* frame;
1037     int rx, ry;
1038     CachedRoot* root = getFrameCache(AllowNewer);
1039     if (!root)
1040         return;
1041     const CachedNode* node = findAt(root, rect, &frame, &rx, &ry);
1042     if (!node) {
1043         DBG_NAV_LOGD("no nodes found root=%p", root);
1044         root->rootHistory()->setMouseBounds(rect);
1045         m_viewImpl->m_hasCursorBounds = false;
1046         root->setCursor(0, 0);
1047         viewInvalidate();
1048     } else {
1049         DBG_NAV_LOGD("CachedNode:%p (%d)", node, node->index());
1050         WebCore::IntRect bounds = node->bounds(frame);
1051         root->rootHistory()->setMouseBounds(bounds);
1052         m_viewImpl->updateCursorBounds(root, frame, node);
1053         showCursorTimed();
1054         root->setCursor(const_cast<CachedFrame*>(frame),
1055                 const_cast<CachedNode*>(node));
1056     }
1057     sendMoveMouseIfLatest(false, false);
1058 }
1059
1060 const CachedNode* m_cacheHitNode;
1061 const CachedFrame* m_cacheHitFrame;
1062
1063 bool pointInNavCache(int x, int y, int slop)
1064 {
1065     CachedRoot* root = getFrameCache(AllowNewer);
1066     if (!root)
1067         return false;
1068     IntRect rect = IntRect(x - slop, y - slop, slop * 2, slop * 2);
1069     int rx, ry;
1070     return (m_cacheHitNode = findAt(root, rect, &m_cacheHitFrame, &rx, &ry));
1071 }
1072
1073 bool motionUp(int x, int y, int slop)
1074 {
1075     bool pageScrolled = false;
1076     IntRect rect = IntRect(x - slop, y - slop, slop * 2, slop * 2);
1077     int rx, ry;
1078     CachedRoot* root = getFrameCache(AllowNewer);
1079     if (!root)
1080         return 0;
1081     const CachedFrame* frame = 0;
1082     const CachedNode* result = findAt(root, rect, &frame, &rx, &ry);
1083     CachedHistory* history = root->rootHistory();
1084     if (!result) {
1085         DBG_NAV_LOGD("no nodes found root=%p", root);
1086         history->setNavBounds(rect);
1087         m_viewImpl->m_hasCursorBounds = false;
1088         root->hideCursor();
1089         int dx = root->checkForCenter(x, y);
1090         if (dx) {
1091             scrollBy(dx, 0);
1092             pageScrolled = true;
1093         }
1094         sendMotionUp(frame ? (WebCore::Frame*) frame->framePointer() : 0,
1095             0, x, y);
1096         viewInvalidate();
1097         return pageScrolled;
1098     }
1099     DBG_NAV_LOGD("CachedNode:%p (%d) x=%d y=%d rx=%d ry=%d", result,
1100         result->index(), x, y, rx, ry);
1101     WebCore::IntRect navBounds = WebCore::IntRect(rx, ry, 1, 1);
1102     history->setNavBounds(navBounds);
1103     history->setMouseBounds(navBounds);
1104     m_viewImpl->updateCursorBounds(root, frame, result);
1105     root->setCursor(const_cast<CachedFrame*>(frame),
1106         const_cast<CachedNode*>(result));
1107     if (result->isSyntheticLink())
1108         overrideUrlLoading(result->getExport());
1109     else {
1110         sendMotionUp(
1111             (WebCore::Frame*) frame->framePointer(),
1112             (WebCore::Node*) result->nodePointer(), rx, ry);
1113     }
1114     if (result->isTextInput() || result->isSelect()
1115             || result->isContentEditable()) {
1116         showCursorUntimed();
1117     } else
1118         showCursorTimed();
1119     return pageScrolled;
1120 }
1121
1122 #if USE(ACCELERATED_COMPOSITING)
1123 static const ScrollableLayerAndroid* findScrollableLayer(
1124     const LayerAndroid* parent, int x, int y, SkIRect* foundBounds) {
1125     SkRect bounds;
1126     parent->bounds(&bounds);
1127     // Check the parent bounds first; this will clip to within a masking layer's
1128     // bounds.
1129     if (parent->masksToBounds() && !bounds.contains(x, y))
1130         return 0;
1131     // Move the hit test local to parent.
1132     x -= bounds.fLeft;
1133     y -= bounds.fTop;
1134     int count = parent->countChildren();
1135     while (count--) {
1136         const LayerAndroid* child = parent->getChild(count);
1137         const ScrollableLayerAndroid* result = findScrollableLayer(child, x, y,
1138             foundBounds);
1139         if (result) {
1140             foundBounds->offset(bounds.fLeft, bounds.fTop);
1141             if (parent->masksToBounds()) {
1142                 if (bounds.width() < foundBounds->width())
1143                     foundBounds->fRight = foundBounds->fLeft + bounds.width();
1144                 if (bounds.height() < foundBounds->height())
1145                     foundBounds->fBottom = foundBounds->fTop + bounds.height();
1146             }
1147             return result;
1148         }
1149     }
1150     if (parent->contentIsScrollable()) {
1151         foundBounds->set(0, 0, bounds.width(), bounds.height());
1152         return static_cast<const ScrollableLayerAndroid*>(parent);
1153     }
1154     return 0;
1155 }
1156 #endif
1157
1158 int scrollableLayer(int x, int y, SkIRect* layerRect, SkIRect* bounds)
1159 {
1160 #if USE(ACCELERATED_COMPOSITING)
1161     const LayerAndroid* layerRoot = compositeRoot();
1162     if (!layerRoot)
1163         return 0;
1164     const ScrollableLayerAndroid* result = findScrollableLayer(layerRoot, x, y,
1165         bounds);
1166     if (result) {
1167         result->getScrollRect(layerRect);
1168         return result->uniqueId();
1169     }
1170 #endif
1171     return 0;
1172 }
1173
1174 int getBlockLeftEdge(int x, int y, float scale)
1175 {
1176     CachedRoot* root = getFrameCache(AllowNewer);
1177     if (root)
1178         return root->getBlockLeftEdge(x, y, scale);
1179     return -1;
1180 }
1181
1182 void overrideUrlLoading(const WTF::String& url)
1183 {
1184     JNIEnv* env = JSC::Bindings::getJNIEnv();
1185     AutoJObject javaObject = m_javaGlue.object(env);
1186     if (!javaObject.get())
1187         return;
1188     jstring jName = wtfStringToJstring(env, url);
1189     env->CallVoidMethod(javaObject.get(), m_javaGlue.m_overrideLoading, jName);
1190     env->DeleteLocalRef(jName);
1191 }
1192
1193 void setFindIsUp(bool up)
1194 {
1195     DBG_NAV_LOGD("up=%d", up);
1196     m_viewImpl->m_findIsUp = up;
1197 }
1198
1199 void setFindIsEmpty()
1200 {
1201     DBG_NAV_LOG("");
1202     m_findOnPage.clearCurrentLocation();
1203 }
1204
1205 void showCursorTimed()
1206 {
1207     DBG_NAV_LOG("");
1208     m_ringAnimationEnd = SkTime::GetMSecs() + PRESSED_STATE_DURATION;
1209     viewInvalidate();
1210 }
1211
1212 void showCursorUntimed()
1213 {
1214     DBG_NAV_LOG("");
1215     m_ring.m_isPressed = false;
1216     m_ringAnimationEnd = UINT_MAX;
1217     viewInvalidate();
1218 }
1219
1220 void setHeightCanMeasure(bool measure)
1221 {
1222     m_heightCanMeasure = measure;
1223 }
1224
1225 String getSelection()
1226 {
1227     return m_selectText.getSelection();
1228 }
1229
1230 void moveSelection(int x, int y)
1231 {
1232     m_selectText.moveSelection(getVisibleRect(), x, y);
1233 }
1234
1235 IntPoint selectableText()
1236 {
1237     const CachedRoot* root = getFrameCache(DontAllowNewer);
1238     if (!root)
1239         return IntPoint(0, 0);
1240     return m_selectText.selectableText(root);
1241 }
1242
1243 void selectAll()
1244 {
1245     m_selectText.selectAll();
1246 }
1247
1248 int selectionX()
1249 {
1250     return m_selectText.selectionX();
1251 }
1252
1253 int selectionY()
1254 {
1255     return m_selectText.selectionY();
1256 }
1257
1258 void resetSelection()
1259 {
1260     m_selectText.reset();
1261 }
1262
1263 bool startSelection(int x, int y)
1264 {
1265     const CachedRoot* root = getFrameCache(DontAllowNewer);
1266     if (!root)
1267         return false;
1268     updateSelectionHandles();
1269     return m_selectText.startSelection(root, getVisibleRect(), x, y);
1270 }
1271
1272 bool wordSelection(int x, int y)
1273 {
1274     const CachedRoot* root = getFrameCache(DontAllowNewer);
1275     if (!root)
1276         return false;
1277     updateSelectionHandles();
1278     return m_selectText.wordSelection(root, getVisibleRect(), x, y);
1279 }
1280
1281 bool extendSelection(int x, int y)
1282 {
1283     m_selectText.extendSelection(getVisibleRect(), x, y);
1284     return true;
1285 }
1286
1287 bool hitSelection(int x, int y)
1288 {
1289     updateSelectionHandles();
1290     return m_selectText.hitSelection(x, y);
1291 }
1292
1293 void setExtendSelection()
1294 {
1295     m_selectText.setExtendSelection(true);
1296 }
1297
1298 void setSelectionPointer(bool set, float scale, int x, int y)
1299 {
1300     m_selectText.setDrawPointer(set);
1301     if (!set)
1302         return;
1303     m_selectText.m_inverseScale = scale;
1304     m_selectText.m_selectX = x;
1305     m_selectText.m_selectY = y;
1306 }
1307
1308 void sendMoveFocus(WebCore::Frame* framePtr, WebCore::Node* nodePtr)
1309 {
1310     DBG_NAV_LOGD("framePtr=%p nodePtr=%p", framePtr, nodePtr);
1311     JNIEnv* env = JSC::Bindings::getJNIEnv();
1312     AutoJObject javaObject = m_javaGlue.object(env);
1313     if (!javaObject.get())
1314         return;
1315     env->CallVoidMethod(javaObject.get(), m_javaGlue.m_sendMoveFocus, (jint) framePtr, (jint) nodePtr);
1316     checkException(env);
1317 }
1318
1319 void sendMoveMouse(WebCore::Frame* framePtr, WebCore::Node* nodePtr, int x, int y)
1320 {
1321     DBG_NAV_LOGD("framePtr=%p nodePtr=%p x=%d y=%d", framePtr, nodePtr, x, y);
1322     JNIEnv* env = JSC::Bindings::getJNIEnv();
1323     AutoJObject javaObject = m_javaGlue.object(env);
1324     if (!javaObject.get())
1325         return;
1326     env->CallVoidMethod(javaObject.get(), m_javaGlue.m_sendMoveMouse, reinterpret_cast<jint>(framePtr), reinterpret_cast<jint>(nodePtr), x, y);
1327     checkException(env);
1328 }
1329
1330 void sendMoveMouseIfLatest(bool clearTextEntry, bool stopPaintingCaret)
1331 {
1332     LOG_ASSERT(m_javaGlue.m_obj, "A java object was not associated with this native WebView!");
1333     JNIEnv* env = JSC::Bindings::getJNIEnv();
1334     AutoJObject javaObject = m_javaGlue.object(env);
1335     if (!javaObject.get())
1336         return;
1337     env->CallVoidMethod(javaObject.get(), m_javaGlue.m_sendMoveMouseIfLatest, clearTextEntry, stopPaintingCaret);
1338     checkException(env);
1339 }
1340
1341 void sendMotionUp(WebCore::Frame* framePtr, WebCore::Node* nodePtr, int x, int y)
1342 {
1343     DBG_NAV_LOGD("m_generation=%d framePtr=%p nodePtr=%p x=%d y=%d", m_generation, framePtr, nodePtr, x, y);
1344     LOG_ASSERT(m_javaGlue.m_obj, "A WebView was not associated with this WebViewNative!");
1345
1346     JNIEnv* env = JSC::Bindings::getJNIEnv();
1347     AutoJObject javaObject = m_javaGlue.object(env);
1348     if (!javaObject.get())
1349         return;
1350     m_viewImpl->m_touchGeneration = ++m_generation;
1351     env->CallVoidMethod(javaObject.get(), m_javaGlue.m_sendMotionUp, m_generation, (jint) framePtr, (jint) nodePtr, x, y);
1352     checkException(env);
1353 }
1354
1355 void findNext(bool forward)
1356 {
1357     m_findOnPage.findNext(forward);
1358     scrollToCurrentMatch();
1359     viewInvalidate();
1360 }
1361
1362 // With this call, WebView takes ownership of matches, and is responsible for
1363 // deleting it.
1364 void setMatches(WTF::Vector<MatchInfo>* matches, jboolean sameAsLastSearch)
1365 {
1366     // If this search is the same as the last one, check against the old
1367     // location to determine whether to scroll.  If the same word is found
1368     // in the same place, then do not scroll.
1369     IntRect oldLocation;
1370     bool checkAgainstOldLocation = false;
1371     if (sameAsLastSearch && m_findOnPage.isCurrentLocationValid()) {
1372         oldLocation = m_findOnPage.currentMatchBounds();
1373         checkAgainstOldLocation = true;
1374     }
1375
1376     m_findOnPage.setMatches(matches);
1377
1378     if (!checkAgainstOldLocation || oldLocation != m_findOnPage.currentMatchBounds())
1379         scrollToCurrentMatch();
1380     viewInvalidate();
1381 }
1382
1383 int currentMatchIndex()
1384 {
1385     return m_findOnPage.currentMatchIndex();
1386 }
1387
1388 bool scrollBy(int dx, int dy)
1389 {
1390     LOG_ASSERT(m_javaGlue.m_obj, "A java object was not associated with this native WebView!");
1391
1392     JNIEnv* env = JSC::Bindings::getJNIEnv();
1393     AutoJObject javaObject = m_javaGlue.object(env);
1394     if (!javaObject.get())
1395         return false;
1396     bool result = env->CallBooleanMethod(javaObject.get(), m_javaGlue.m_scrollBy, dx, dy, true);
1397     checkException(env);
1398     return result;
1399 }
1400
1401 void setIsScrolling(bool isScrolling)
1402 {
1403 #if USE(ACCELERATED_COMPOSITING)
1404     if (m_glWebViewState)
1405         m_glWebViewState->setIsScrolling(isScrolling);
1406 #endif
1407 }
1408
1409 bool hasCursorNode()
1410 {
1411     CachedRoot* root = getFrameCache(DontAllowNewer);
1412     if (!root) {
1413         DBG_NAV_LOG("!root");
1414         return false;
1415     }
1416     const CachedNode* cursorNode = root->currentCursor();
1417     DBG_NAV_LOGD("cursorNode=%d (nodePointer=%p)",
1418         cursorNode ? cursorNode->index() : -1,
1419         cursorNode ? cursorNode->nodePointer() : 0);
1420     return cursorNode;
1421 }
1422
1423 bool hasFocusNode()
1424 {
1425     CachedRoot* root = getFrameCache(DontAllowNewer);
1426     if (!root) {
1427         DBG_NAV_LOG("!root");
1428         return false;
1429     }
1430     const CachedNode* focusNode = root->currentFocus();
1431     DBG_NAV_LOGD("focusNode=%d (nodePointer=%p)",
1432         focusNode ? focusNode->index() : -1,
1433         focusNode ? focusNode->nodePointer() : 0);
1434     return focusNode;
1435 }
1436
1437 void rebuildWebTextView()
1438 {
1439     JNIEnv* env = JSC::Bindings::getJNIEnv();
1440     AutoJObject javaObject = m_javaGlue.object(env);
1441     if (!javaObject.get())
1442         return;
1443     env->CallVoidMethod(javaObject.get(), m_javaGlue.m_rebuildWebTextView);
1444     checkException(env);
1445 }
1446
1447 void viewInvalidate()
1448 {
1449     JNIEnv* env = JSC::Bindings::getJNIEnv();
1450     AutoJObject javaObject = m_javaGlue.object(env);
1451     if (!javaObject.get())
1452         return;
1453     env->CallVoidMethod(javaObject.get(), m_javaGlue.m_viewInvalidate);
1454     checkException(env);
1455 }
1456
1457 void viewInvalidateRect(int l, int t, int r, int b)
1458 {
1459     JNIEnv* env = JSC::Bindings::getJNIEnv();
1460     AutoJObject javaObject = m_javaGlue.object(env);
1461     if (!javaObject.get())
1462         return;
1463     env->CallVoidMethod(javaObject.get(), m_javaGlue.m_viewInvalidateRect, l, r, t, b);
1464     checkException(env);
1465 }
1466
1467 void postInvalidateDelayed(int64_t delay, const WebCore::IntRect& bounds)
1468 {
1469     JNIEnv* env = JSC::Bindings::getJNIEnv();
1470     AutoJObject javaObject = m_javaGlue.object(env);
1471     if (!javaObject.get())
1472         return;
1473     env->CallVoidMethod(javaObject.get(), m_javaGlue.m_postInvalidateDelayed,
1474         delay, bounds.x(), bounds.y(), bounds.maxX(), bounds.maxY());
1475     checkException(env);
1476 }
1477
1478 bool inFullScreenMode()
1479 {
1480     JNIEnv* env = JSC::Bindings::getJNIEnv();
1481     AutoJObject javaObject = m_javaGlue.object(env);
1482     if (!javaObject.get())
1483         return false;
1484     jboolean result = env->CallBooleanMethod(javaObject.get(), m_javaGlue.m_inFullScreenMode);
1485     checkException(env);
1486     return result;
1487 }
1488
1489 int moveGeneration()
1490 {
1491     return m_viewImpl->m_moveGeneration;
1492 }
1493
1494 LayerAndroid* compositeRoot() const
1495 {
1496     LOG_ASSERT(!m_baseLayer || m_baseLayer->countChildren() == 1,
1497             "base layer can't have more than one child %s", __FUNCTION__);
1498     if (m_baseLayer && m_baseLayer->countChildren() == 1)
1499         return static_cast<LayerAndroid*>(m_baseLayer->getChild(0));
1500     else
1501         return 0;
1502 }
1503
1504 #if ENABLE(ANDROID_OVERFLOW_SCROLL)
1505 static void copyScrollPositionRecursive(const LayerAndroid* from,
1506                                         LayerAndroid* root)
1507 {
1508     if (!from || !root)
1509         return;
1510     for (int i = 0; i < from->countChildren(); i++) {
1511         const LayerAndroid* l = from->getChild(i);
1512         if (l->contentIsScrollable()) {
1513             const SkPoint& pos = l->getPosition();
1514             LayerAndroid* match = root->findById(l->uniqueId());
1515             if (match && match->contentIsScrollable())
1516                 match->setPosition(pos.fX, pos.fY);
1517         }
1518         copyScrollPositionRecursive(l, root);
1519     }
1520 }
1521 #endif
1522
1523 void registerPageSwapCallback()
1524 {
1525     m_pageSwapCallbackRegistered = true;
1526 }
1527
1528 void setBaseLayer(BaseLayerAndroid* layer, SkRegion& inval, bool showVisualIndicator,
1529                   bool isPictureAfterFirstLayout, bool registerPageSwapCallback)
1530 {
1531 #if USE(ACCELERATED_COMPOSITING)
1532     if (m_glWebViewState)
1533         m_glWebViewState->setBaseLayer(layer, inval, showVisualIndicator,
1534                                        isPictureAfterFirstLayout);
1535     m_pageSwapCallbackRegistered |= registerPageSwapCallback;
1536 #endif
1537
1538 #if ENABLE(ANDROID_OVERFLOW_SCROLL)
1539     if (layer) {
1540         LayerAndroid* newCompositeRoot = static_cast<LayerAndroid*>(layer->getChild(0));
1541         copyScrollPositionRecursive(compositeRoot(), newCompositeRoot);
1542     }
1543 #endif
1544     SkSafeUnref(m_baseLayer);
1545     m_baseLayer = layer;
1546     CachedRoot* root = getFrameCache(DontAllowNewer);
1547     if (!root)
1548         return;
1549     root->resetLayers();
1550     root->setRootLayer(compositeRoot());
1551 }
1552
1553 void getTextSelectionRegion(SkRegion *region)
1554 {
1555     m_selectText.getSelectionRegion(getVisibleRect(), region, compositeRoot());
1556 }
1557
1558 void getTextSelectionHandles(int* handles)
1559 {
1560     m_selectText.getSelectionHandles(handles);
1561 }
1562
1563 void replaceBaseContent(PictureSet* set)
1564 {
1565     if (!m_baseLayer)
1566         return;
1567     m_baseLayer->setContent(*set);
1568     delete set;
1569 }
1570
1571 void copyBaseContentToPicture(SkPicture* picture)
1572 {
1573     if (!m_baseLayer)
1574         return;
1575     PictureSet* content = m_baseLayer->content();
1576     m_baseLayer->drawCanvas(picture->beginRecording(content->width(), content->height(),
1577             SkPicture::kUsePathBoundsForClip_RecordingFlag));
1578     picture->endRecording();
1579 }
1580
1581 bool hasContent() {
1582     if (!m_baseLayer)
1583         return false;
1584     return !m_baseLayer->content()->isEmpty();
1585 }
1586
1587 void setFunctor(Functor* functor) {
1588     delete m_glDrawFunctor;
1589     m_glDrawFunctor = functor;
1590 }
1591
1592 Functor* getFunctor() {
1593     return m_glDrawFunctor;
1594 }
1595
1596 BaseLayerAndroid* getBaseLayer() {
1597     return m_baseLayer;
1598 }
1599
1600 private: // local state for WebView
1601     // private to getFrameCache(); other functions operate in a different thread
1602     CachedRoot* m_frameCacheUI; // navigation data ready for use
1603     WebViewCore* m_viewImpl;
1604     int m_generation; // associate unique ID with sent kit focus to match with ui
1605     SkPicture* m_navPictureUI;
1606     SkMSec m_ringAnimationEnd;
1607     // Corresponds to the same-named boolean on the java side.
1608     bool m_heightCanMeasure;
1609     int m_lastDx;
1610     SkMSec m_lastDxTime;
1611     SelectText m_selectText;
1612     FindOnPage m_findOnPage;
1613     CursorRing m_ring;
1614     BaseLayerAndroid* m_baseLayer;
1615     Functor* m_glDrawFunctor;
1616 #if USE(ACCELERATED_COMPOSITING)
1617     GLWebViewState* m_glWebViewState;
1618     bool m_pageSwapCallbackRegistered;
1619 #endif
1620     RenderSkinButton* m_buttonSkin;
1621 }; // end of WebView class
1622
1623
1624 /**
1625  * This class holds a function pointer and parameters for calling drawGL into a specific
1626  * viewport. The pointer to the Functor will be put on a framework display list to be called
1627  * when the display list is replayed.
1628  */
1629 class GLDrawFunctor : Functor {
1630     public:
1631     GLDrawFunctor(WebView* _wvInstance,
1632             bool(WebView::*_funcPtr)(WebCore::IntRect&, WebCore::IntRect*, WebCore::IntRect&, int, WebCore::IntRect&, jfloat, jint),
1633             WebCore::IntRect _viewRect, float _scale, int _extras) {
1634         wvInstance = _wvInstance;
1635         funcPtr = _funcPtr;
1636         viewRect = _viewRect;
1637         scale = _scale;
1638         extras = _extras;
1639     };
1640     status_t operator()(int messageId, void* data) {
1641         if (viewRect.isEmpty()) {
1642             // NOOP operation if viewport is empty
1643             return 0;
1644         }
1645
1646         WebCore::IntRect inval;
1647         int titlebarHeight = webViewRect.height() - viewRect.height();
1648
1649         uirenderer::DrawGlInfo* info = reinterpret_cast<uirenderer::DrawGlInfo*>(data);
1650         WebCore::IntRect localViewRect = viewRect;
1651         if (info->isLayer)
1652             localViewRect.move(-1 * localViewRect.x(), -1 * localViewRect.y());
1653
1654         WebCore::IntRect clip(info->clipLeft, info->clipTop,
1655                               info->clipRight - info->clipLeft,
1656                               info->clipBottom - info->clipTop);
1657
1658         bool retVal = (*wvInstance.*funcPtr)(localViewRect, &inval, webViewRect, titlebarHeight, clip, scale, extras);
1659         if (retVal) {
1660             IntRect finalInval;
1661             if (inval.isEmpty()) {
1662                 finalInval = webViewRect;
1663                 retVal = true;
1664             } else {
1665                 finalInval.setX(webViewRect.x() + inval.x());
1666                 finalInval.setY(webViewRect.y() + titlebarHeight + inval.y());
1667                 finalInval.setWidth(inval.width());
1668                 finalInval.setHeight(inval.height());
1669             }
1670             info->dirtyLeft = finalInval.x();
1671             info->dirtyTop = finalInval.y();
1672             info->dirtyRight = finalInval.maxX();
1673             info->dirtyBottom = finalInval.maxY();
1674         }
1675         // return 1 if invalidation needed, 0 otherwise
1676         return retVal ? 1 : 0;
1677     }
1678     void updateRect(WebCore::IntRect& _viewRect) {
1679         viewRect = _viewRect;
1680     }
1681     void updateViewRect(WebCore::IntRect& _viewRect) {
1682         webViewRect = _viewRect;
1683     }
1684     private:
1685     WebView* wvInstance;
1686     bool (WebView::*funcPtr)(WebCore::IntRect&, WebCore::IntRect*, WebCore::IntRect&, int, WebCore::IntRect&, float, int);
1687     WebCore::IntRect viewRect;
1688     WebCore::IntRect webViewRect;
1689     jfloat scale;
1690     jint extras;
1691 };
1692
1693 static jobject createJavaRect(JNIEnv* env, int x, int y, int right, int bottom)
1694 {
1695     jclass rectClass = env->FindClass("android/graphics/Rect");
1696     jmethodID init = env->GetMethodID(rectClass, "<init>", "(IIII)V");
1697     jobject rect = env->NewObject(rectClass, init, x, y, right, bottom);
1698     env->DeleteLocalRef(rectClass);
1699     return rect;
1700 }
1701
1702 /*
1703  * Native JNI methods
1704  */
1705 static int nativeCacheHitFramePointer(JNIEnv *env, jobject obj)
1706 {
1707     return reinterpret_cast<int>(GET_NATIVE_VIEW(env, obj)
1708             ->m_cacheHitFrame->framePointer());
1709 }
1710
1711 static jobject nativeCacheHitNodeBounds(JNIEnv *env, jobject obj)
1712 {
1713     WebCore::IntRect bounds = GET_NATIVE_VIEW(env, obj)
1714         ->m_cacheHitNode->originalAbsoluteBounds();
1715     return createJavaRect(env, bounds.x(), bounds.y(),
1716                           bounds.maxX(), bounds.maxY());
1717 }
1718
1719 static int nativeCacheHitNodePointer(JNIEnv *env, jobject obj)
1720 {
1721     return reinterpret_cast<int>(GET_NATIVE_VIEW(env, obj)
1722         ->m_cacheHitNode->nodePointer());
1723 }
1724
1725 static bool nativeCacheHitIsPlugin(JNIEnv *env, jobject obj)
1726 {
1727     return GET_NATIVE_VIEW(env, obj)->m_cacheHitNode->isPlugin();
1728 }
1729
1730 static void nativeClearCursor(JNIEnv *env, jobject obj)
1731 {
1732     WebView* view = GET_NATIVE_VIEW(env, obj);
1733     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
1734     view->clearCursor();
1735 }
1736
1737 static void nativeCreate(JNIEnv *env, jobject obj, int viewImpl, jstring drawableDir)
1738 {
1739     WTF::String dir = jstringToWtfString(env, drawableDir);
1740     WebView* webview = new WebView(env, obj, viewImpl, dir);
1741     // NEED THIS OR SOMETHING LIKE IT!
1742     //Release(obj);
1743 }
1744
1745 static jint nativeCursorFramePointer(JNIEnv *env, jobject obj)
1746 {
1747     WebView* view = GET_NATIVE_VIEW(env, obj);
1748     CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
1749     if (!root)
1750         return 0;
1751     const CachedFrame* frame = 0;
1752     (void) root->currentCursor(&frame);
1753     return reinterpret_cast<int>(frame ? frame->framePointer() : 0);
1754 }
1755
1756 static const CachedNode* getCursorNode(JNIEnv *env, jobject obj)
1757 {
1758     WebView* view = GET_NATIVE_VIEW(env, obj);
1759     CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
1760     return root ? root->currentCursor() : 0;
1761 }
1762
1763 static const CachedNode* getCursorNode(JNIEnv *env, jobject obj,
1764     const CachedFrame** frame)
1765 {
1766     WebView* view = GET_NATIVE_VIEW(env, obj);
1767     CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
1768     return root ? root->currentCursor(frame) : 0;
1769 }
1770
1771 static const CachedNode* getFocusCandidate(JNIEnv *env, jobject obj,
1772     const CachedFrame** frame)
1773 {
1774     WebView* view = GET_NATIVE_VIEW(env, obj);
1775     CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
1776     if (!root)
1777         return 0;
1778     const CachedNode* cursor = root->currentCursor(frame);
1779     if (cursor && cursor->wantsKeyEvents())
1780         return cursor;
1781     return root->currentFocus(frame);
1782 }
1783
1784 static bool focusCandidateHasNextTextfield(JNIEnv *env, jobject obj)
1785 {
1786     WebView* view = GET_NATIVE_VIEW(env, obj);
1787     CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
1788     if (!root)
1789         return false;
1790     const CachedNode* cursor = root->currentCursor();
1791     if (!cursor || !cursor->isTextInput())
1792         cursor = root->currentFocus();
1793     if (!cursor || !cursor->isTextInput()) return false;
1794     return root->nextTextField(cursor, 0);
1795 }
1796
1797 static const CachedNode* getFocusNode(JNIEnv *env, jobject obj)
1798 {
1799     WebView* view = GET_NATIVE_VIEW(env, obj);
1800     CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
1801     return root ? root->currentFocus() : 0;
1802 }
1803
1804 static const CachedNode* getFocusNode(JNIEnv *env, jobject obj,
1805     const CachedFrame** frame)
1806 {
1807     WebView* view = GET_NATIVE_VIEW(env, obj);
1808     CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
1809     return root ? root->currentFocus(frame) : 0;
1810 }
1811
1812 static const CachedInput* getInputCandidate(JNIEnv *env, jobject obj)
1813 {
1814     WebView* view = GET_NATIVE_VIEW(env, obj);
1815     CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
1816     if (!root)
1817         return 0;
1818     const CachedFrame* frame;
1819     const CachedNode* cursor = root->currentCursor(&frame);
1820     if (!cursor || !cursor->wantsKeyEvents())
1821         cursor = root->currentFocus(&frame);
1822     return cursor ? frame->textInput(cursor) : 0;
1823 }
1824
1825 static jboolean nativePageShouldHandleShiftAndArrows(JNIEnv *env, jobject obj)
1826 {
1827     const CachedNode* focus = getFocusNode(env, obj);
1828     if (!focus) return false;
1829     // Plugins handle shift and arrows whether or not they have focus.
1830     if (focus->isPlugin()) return true;
1831     const CachedNode* cursor = getCursorNode(env, obj);
1832     // ContentEditable nodes should only receive shift and arrows if they have
1833     // both the cursor and the focus.
1834     return cursor && cursor->nodePointer() == focus->nodePointer()
1835             && cursor->isContentEditable();
1836 }
1837
1838 static jobject nativeCursorNodeBounds(JNIEnv *env, jobject obj)
1839 {
1840     const CachedFrame* frame;
1841     const CachedNode* node = getCursorNode(env, obj, &frame);
1842     WebCore::IntRect bounds = node ? node->bounds(frame)
1843         : WebCore::IntRect(0, 0, 0, 0);
1844     return createJavaRect(env, bounds.x(), bounds.y(),
1845                           bounds.maxX(), bounds.maxY());
1846 }
1847
1848 static jint nativeCursorNodePointer(JNIEnv *env, jobject obj)
1849 {
1850     const CachedNode* node = getCursorNode(env, obj);
1851     return reinterpret_cast<int>(node ? node->nodePointer() : 0);
1852 }
1853
1854 static jobject nativeCursorPosition(JNIEnv *env, jobject obj)
1855 {
1856     WebView* view = GET_NATIVE_VIEW(env, obj);
1857     const CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
1858     WebCore::IntPoint pos = WebCore::IntPoint(0, 0);
1859     if (root)
1860         root->getSimulatedMousePosition(&pos);
1861     jclass pointClass = env->FindClass("android/graphics/Point");
1862     jmethodID init = env->GetMethodID(pointClass, "<init>", "(II)V");
1863     jobject point = env->NewObject(pointClass, init, pos.x(), pos.y());
1864     env->DeleteLocalRef(pointClass);
1865     return point;
1866 }
1867
1868 static WebCore::IntRect jrect_to_webrect(JNIEnv* env, jobject obj)
1869 {
1870     int L, T, R, B;
1871     GraphicsJNI::get_jrect(env, obj, &L, &T, &R, &B);
1872     return WebCore::IntRect(L, T, R - L, B - T);
1873 }
1874
1875 static bool nativeCursorIntersects(JNIEnv *env, jobject obj, jobject visRect)
1876 {
1877     const CachedFrame* frame;
1878     const CachedNode* node = getCursorNode(env, obj, &frame);
1879     return node ? node->bounds(frame).intersects(
1880         jrect_to_webrect(env, visRect)) : false;
1881 }
1882
1883 static bool nativeCursorIsAnchor(JNIEnv *env, jobject obj)
1884 {
1885     const CachedNode* node = getCursorNode(env, obj);
1886     return node ? node->isAnchor() : false;
1887 }
1888
1889 static bool nativeCursorIsTextInput(JNIEnv *env, jobject obj)
1890 {
1891     const CachedNode* node = getCursorNode(env, obj);
1892     return node ? node->isTextInput() : false;
1893 }
1894
1895 static jobject nativeCursorText(JNIEnv *env, jobject obj)
1896 {
1897     const CachedNode* node = getCursorNode(env, obj);
1898     if (!node)
1899         return 0;
1900     WTF::String value = node->getExport();
1901     return wtfStringToJstring(env, value);
1902 }
1903
1904 static void nativeDebugDump(JNIEnv *env, jobject obj)
1905 {
1906 #if DUMP_NAV_CACHE
1907     WebView* view = GET_NATIVE_VIEW(env, obj);
1908     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
1909     view->debugDump();
1910 #endif
1911 }
1912
1913 static jint nativeDraw(JNIEnv *env, jobject obj, jobject canv, jint color,
1914         jint extras, jboolean split) {
1915     SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, canv);
1916     return reinterpret_cast<jint>(GET_NATIVE_VIEW(env, obj)->draw(canvas, color, extras, split));
1917 }
1918
1919 static jint nativeGetDrawGLFunction(JNIEnv *env, jobject obj, jint nativeView,
1920                                     jobject jrect, jobject jviewrect,
1921                                     jfloat scale, jint extras) {
1922     WebCore::IntRect viewRect;
1923     if (jrect == NULL) {
1924         viewRect = WebCore::IntRect();
1925     } else {
1926         viewRect = jrect_to_webrect(env, jrect);
1927     }
1928     WebView *wvInstance = (WebView*) nativeView;
1929     GLDrawFunctor* functor = new GLDrawFunctor(wvInstance, &android::WebView::drawGL,
1930             viewRect, scale, extras);
1931     wvInstance->setFunctor((Functor*) functor);
1932
1933     WebCore::IntRect webViewRect;
1934     if (jviewrect == NULL) {
1935         webViewRect = WebCore::IntRect();
1936     } else {
1937         webViewRect = jrect_to_webrect(env, jviewrect);
1938     }
1939     functor->updateViewRect(webViewRect);
1940
1941     return (jint)functor;
1942 }
1943
1944 static void nativeUpdateDrawGLFunction(JNIEnv *env, jobject obj, jobject jrect, jobject jviewrect) {
1945     WebView *wvInstance = GET_NATIVE_VIEW(env, obj);
1946     if (wvInstance != NULL) {
1947         GLDrawFunctor* functor = (GLDrawFunctor*) wvInstance->getFunctor();
1948         if (functor != NULL) {
1949             WebCore::IntRect viewRect;
1950             if (jrect == NULL) {
1951                 viewRect = WebCore::IntRect();
1952             } else {
1953                 viewRect = jrect_to_webrect(env, jrect);
1954             }
1955             functor->updateRect(viewRect);
1956
1957             WebCore::IntRect webViewRect;
1958             if (jviewrect == NULL) {
1959                 webViewRect = WebCore::IntRect();
1960             } else {
1961                 webViewRect = jrect_to_webrect(env, jviewrect);
1962             }
1963             functor->updateViewRect(webViewRect);
1964         }
1965     }
1966 }
1967
1968 static bool nativeEvaluateLayersAnimations(JNIEnv *env, jobject obj, jint nativeView)
1969 {
1970 #if USE(ACCELERATED_COMPOSITING)
1971     LayerAndroid* root = ((WebView*)nativeView)->compositeRoot();
1972     if (root)
1973         return root->evaluateAnimations();
1974 #endif
1975     return false;
1976 }
1977
1978 static void nativeSetBaseLayer(JNIEnv *env, jobject obj, jint layer, jobject inval,
1979                                 jboolean showVisualIndicator,
1980                                 jboolean isPictureAfterFirstLayout,
1981                                 jboolean registerPageSwapCallback)
1982 {
1983     BaseLayerAndroid* layerImpl = reinterpret_cast<BaseLayerAndroid*>(layer);
1984     SkRegion invalRegion;
1985     if (inval)
1986         invalRegion = *GraphicsJNI::getNativeRegion(env, inval);
1987     GET_NATIVE_VIEW(env, obj)->setBaseLayer(layerImpl, invalRegion, showVisualIndicator,
1988                                             isPictureAfterFirstLayout,
1989                                             registerPageSwapCallback);
1990 }
1991
1992 static void nativeGetTextSelectionRegion(JNIEnv *env, jobject obj, jint view,
1993                                          jobject region)
1994 {
1995     if (!region)
1996         return;
1997     SkRegion* nregion = GraphicsJNI::getNativeRegion(env, region);
1998     ((WebView*)view)->getTextSelectionRegion(nregion);
1999 }
2000
2001 static void nativeGetSelectionHandles(JNIEnv *env, jobject obj, jint view,
2002                                       jintArray arr)
2003 {
2004     int handles[4];
2005     ((WebView*)view)->getTextSelectionHandles(handles);
2006     env->SetIntArrayRegion(arr, 0, 4, handles);
2007     checkException(env);
2008 }
2009
2010 static BaseLayerAndroid* nativeGetBaseLayer(JNIEnv *env, jobject obj)
2011 {
2012     return GET_NATIVE_VIEW(env, obj)->getBaseLayer();
2013 }
2014
2015 static void nativeReplaceBaseContent(JNIEnv *env, jobject obj, jint content)
2016 {
2017     PictureSet* set = reinterpret_cast<PictureSet*>(content);
2018     GET_NATIVE_VIEW(env, obj)->replaceBaseContent(set);
2019 }
2020
2021 static void nativeCopyBaseContentToPicture(JNIEnv *env, jobject obj, jobject pict)
2022 {
2023     SkPicture* picture = GraphicsJNI::getNativePicture(env, pict);
2024     GET_NATIVE_VIEW(env, obj)->copyBaseContentToPicture(picture);
2025 }
2026
2027 static bool nativeHasContent(JNIEnv *env, jobject obj)
2028 {
2029     return GET_NATIVE_VIEW(env, obj)->hasContent();
2030 }
2031
2032 static jobject nativeImageURI(JNIEnv *env, jobject obj, jint x, jint y)
2033 {
2034     WebView* view = GET_NATIVE_VIEW(env, obj);
2035     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
2036     WTF::String uri = view->imageURI(x, y);
2037     return wtfStringToJstring(env, uri);
2038 }
2039
2040 static jint nativeFocusCandidateFramePointer(JNIEnv *env, jobject obj)
2041 {
2042     WebView* view = GET_NATIVE_VIEW(env, obj);
2043     CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
2044     if (!root)
2045         return 0;
2046     const CachedFrame* frame = 0;
2047     const CachedNode* cursor = root->currentCursor(&frame);
2048     if (!cursor || !cursor->wantsKeyEvents())
2049         (void) root->currentFocus(&frame);
2050     return reinterpret_cast<int>(frame ? frame->framePointer() : 0);
2051 }
2052
2053 static bool nativeFocusCandidateIsPassword(JNIEnv *env, jobject obj)
2054 {
2055     const CachedInput* input = getInputCandidate(env, obj);
2056     return input && input->getType() == CachedInput::PASSWORD;
2057 }
2058
2059 static bool nativeFocusCandidateIsRtlText(JNIEnv *env, jobject obj)
2060 {
2061     const CachedInput* input = getInputCandidate(env, obj);
2062     return input ? input->isRtlText() : false;
2063 }
2064
2065 static bool nativeFocusCandidateIsTextInput(JNIEnv *env, jobject obj)
2066 {
2067     const CachedNode* node = getFocusCandidate(env, obj, 0);
2068     return node ? node->isTextInput() : false;
2069 }
2070
2071 static jint nativeFocusCandidateMaxLength(JNIEnv *env, jobject obj)
2072 {
2073     const CachedInput* input = getInputCandidate(env, obj);
2074     return input ? input->maxLength() : false;
2075 }
2076
2077 static jint nativeFocusCandidateIsAutoComplete(JNIEnv *env, jobject obj)
2078 {
2079     const CachedInput* input = getInputCandidate(env, obj);
2080     return input ? input->autoComplete() : false;
2081 }
2082
2083 static jobject nativeFocusCandidateName(JNIEnv *env, jobject obj)
2084 {
2085     const CachedInput* input = getInputCandidate(env, obj);
2086     if (!input)
2087         return 0;
2088     const WTF::String& name = input->name();
2089     return wtfStringToJstring(env, name);
2090 }
2091
2092 static jobject nativeFocusCandidateNodeBounds(JNIEnv *env, jobject obj)
2093 {
2094     const CachedFrame* frame;
2095     const CachedNode* node = getFocusCandidate(env, obj, &frame);
2096     WebCore::IntRect bounds = node ? node->bounds(frame)
2097         : WebCore::IntRect(0, 0, 0, 0);
2098     // Inset the rect by 1 unit, so that the focus candidate's border can still
2099     // be seen behind it.
2100     return createJavaRect(env, bounds.x() + 1, bounds.y() + 1,
2101                           bounds.maxX() - 1, bounds.maxY() - 1);
2102 }
2103
2104 static jobject nativeFocusCandidatePaddingRect(JNIEnv *env, jobject obj)
2105 {
2106     const CachedInput* input = getInputCandidate(env, obj);
2107     if (!input)
2108         return 0;
2109     // Note that the Java Rect is being used to pass four integers, rather than
2110     // being used as an actual rectangle.
2111     return createJavaRect(env, input->paddingLeft(), input->paddingTop(),
2112             input->paddingRight(), input->paddingBottom());
2113 }
2114
2115 static jint nativeFocusCandidatePointer(JNIEnv *env, jobject obj)
2116 {
2117     const CachedNode* node = getFocusCandidate(env, obj, 0);
2118     return reinterpret_cast<int>(node ? node->nodePointer() : 0);
2119 }
2120
2121 static jint nativeFocusCandidateIsSpellcheck(JNIEnv *env, jobject obj)
2122 {
2123     const CachedInput* input = getInputCandidate(env, obj);
2124     return input ? input->spellcheck() : false;
2125 }
2126
2127 static jobject nativeFocusCandidateText(JNIEnv *env, jobject obj)
2128 {
2129     const CachedNode* node = getFocusCandidate(env, obj, 0);
2130     if (!node)
2131         return 0;
2132     WTF::String value = node->getExport();
2133     return wtfStringToJstring(env, value);
2134 }
2135
2136 static int nativeFocusCandidateLineHeight(JNIEnv *env, jobject obj)
2137 {
2138     const CachedInput* input = getInputCandidate(env, obj);
2139     return input ? input->lineHeight() : 0;
2140 }
2141
2142 static jfloat nativeFocusCandidateTextSize(JNIEnv *env, jobject obj)
2143 {
2144     const CachedInput* input = getInputCandidate(env, obj);
2145     return input ? input->textSize() : 0.f;
2146 }
2147
2148 static int nativeFocusCandidateType(JNIEnv *env, jobject obj)
2149 {
2150     const CachedInput* input = getInputCandidate(env, obj);
2151     if (!input)
2152         return CachedInput::NONE;
2153
2154     if (input->isTextArea())
2155         return CachedInput::TEXT_AREA;
2156
2157     return input->getType();
2158 }
2159
2160 static bool nativeFocusIsPlugin(JNIEnv *env, jobject obj)
2161 {
2162     const CachedNode* node = getFocusNode(env, obj);
2163     return node ? node->isPlugin() : false;
2164 }
2165
2166 static jobject nativeFocusNodeBounds(JNIEnv *env, jobject obj)
2167 {
2168     const CachedFrame* frame;
2169     const CachedNode* node = getFocusNode(env, obj, &frame);
2170     WebCore::IntRect bounds = node ? node->bounds(frame)
2171         : WebCore::IntRect(0, 0, 0, 0);
2172     return createJavaRect(env, bounds.x(), bounds.y(),
2173                           bounds.maxX(), bounds.maxY());
2174 }
2175
2176 static jint nativeFocusNodePointer(JNIEnv *env, jobject obj)
2177 {
2178     const CachedNode* node = getFocusNode(env, obj);
2179     return node ? reinterpret_cast<int>(node->nodePointer()) : 0;
2180 }
2181
2182 static bool nativeCursorWantsKeyEvents(JNIEnv* env, jobject jwebview) {
2183     WebView* view = GET_NATIVE_VIEW(env, jwebview);
2184     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
2185     return view->cursorWantsKeyEvents();
2186 }
2187
2188 static void nativeHideCursor(JNIEnv *env, jobject obj)
2189 {
2190     WebView* view = GET_NATIVE_VIEW(env, obj);
2191     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
2192     view->hideCursor();
2193 }
2194
2195 static void nativeInstrumentReport(JNIEnv *env, jobject obj)
2196 {
2197 #ifdef ANDROID_INSTRUMENT
2198     TimeCounter::reportNow();
2199 #endif
2200 }
2201
2202 static void nativeSelectBestAt(JNIEnv *env, jobject obj, jobject jrect)
2203 {
2204     WebView* view = GET_NATIVE_VIEW(env, obj);
2205     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
2206     WebCore::IntRect rect = jrect_to_webrect(env, jrect);
2207     view->selectBestAt(rect);
2208 }
2209
2210 static void nativeSelectAt(JNIEnv *env, jobject obj, jint x, jint y)
2211 {
2212     WebView* view = GET_NATIVE_VIEW(env, obj);
2213     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
2214     WebCore::IntRect rect = IntRect(x, y , 1, 1);
2215     view->selectBestAt(rect);
2216     if (view->hasCursorNode())
2217         view->showCursorUntimed();
2218 }
2219
2220 static jobject nativeLayerBounds(JNIEnv* env, jobject obj, jint jlayer)
2221 {
2222     SkRect r;
2223 #if USE(ACCELERATED_COMPOSITING)
2224     LayerAndroid* layer = (LayerAndroid*) jlayer;
2225     r = layer->bounds();
2226 #else
2227     r.setEmpty();
2228 #endif
2229     SkIRect irect;
2230     r.round(&irect);
2231     jclass rectClass = env->FindClass("android/graphics/Rect");
2232     jmethodID init = env->GetMethodID(rectClass, "<init>", "(IIII)V");
2233     jobject rect = env->NewObject(rectClass, init, irect.fLeft, irect.fTop,
2234         irect.fRight, irect.fBottom);
2235     env->DeleteLocalRef(rectClass);
2236     return rect;
2237 }
2238
2239 static jobject nativeSubtractLayers(JNIEnv* env, jobject obj, jobject jrect)
2240 {
2241     SkIRect irect = jrect_to_webrect(env, jrect);
2242 #if USE(ACCELERATED_COMPOSITING)
2243     LayerAndroid* root = GET_NATIVE_VIEW(env, obj)->compositeRoot();
2244     if (root) {
2245         SkRect rect;
2246         rect.set(irect);
2247         rect = root->subtractLayers(rect);
2248         rect.round(&irect);
2249     }
2250 #endif
2251     jclass rectClass = env->FindClass("android/graphics/Rect");
2252     jmethodID init = env->GetMethodID(rectClass, "<init>", "(IIII)V");
2253     jobject rect = env->NewObject(rectClass, init, irect.fLeft, irect.fTop,
2254         irect.fRight, irect.fBottom);
2255     env->DeleteLocalRef(rectClass);
2256     return rect;
2257 }
2258
2259 static jint nativeTextGeneration(JNIEnv *env, jobject obj)
2260 {
2261     WebView* view = GET_NATIVE_VIEW(env, obj);
2262     CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
2263     return root ? root->textGeneration() : 0;
2264 }
2265
2266 static bool nativePointInNavCache(JNIEnv *env, jobject obj,
2267     int x, int y, int slop)
2268 {
2269     return GET_NATIVE_VIEW(env, obj)->pointInNavCache(x, y, slop);
2270 }
2271
2272 static bool nativeMotionUp(JNIEnv *env, jobject obj,
2273     int x, int y, int slop)
2274 {
2275     WebView* view = GET_NATIVE_VIEW(env, obj);
2276     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
2277     return view->motionUp(x, y, slop);
2278 }
2279
2280 static bool nativeHasCursorNode(JNIEnv *env, jobject obj)
2281 {
2282     return GET_NATIVE_VIEW(env, obj)->hasCursorNode();
2283 }
2284
2285 static bool nativeHasFocusNode(JNIEnv *env, jobject obj)
2286 {
2287     return GET_NATIVE_VIEW(env, obj)->hasFocusNode();
2288 }
2289
2290 static bool nativeMoveCursor(JNIEnv *env, jobject obj,
2291     int key, int count, bool ignoreScroll)
2292 {
2293     WebView* view = GET_NATIVE_VIEW(env, obj);
2294     DBG_NAV_LOGD("env=%p obj=%p view=%p", env, obj, view);
2295     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
2296     return view->moveCursor(key, count, ignoreScroll);
2297 }
2298
2299 static void nativeRecordButtons(JNIEnv* env, jobject obj, jint nativeView,
2300                                 bool hasFocus, bool pressed, bool invalidate)
2301 {
2302     WebView* view = (WebView*) nativeView;
2303     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
2304     view->nativeRecordButtons(hasFocus, pressed, invalidate);
2305 }
2306
2307 static void nativeSetFindIsUp(JNIEnv *env, jobject obj, jboolean isUp)
2308 {
2309     WebView* view = GET_NATIVE_VIEW(env, obj);
2310     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
2311     view->setFindIsUp(isUp);
2312 }
2313
2314 static void nativeSetFindIsEmpty(JNIEnv *env, jobject obj)
2315 {
2316     GET_NATIVE_VIEW(env, obj)->setFindIsEmpty();
2317 }
2318
2319 static void nativeShowCursorTimed(JNIEnv *env, jobject obj)
2320 {
2321     GET_NATIVE_VIEW(env, obj)->showCursorTimed();
2322 }
2323
2324 static void nativeSetHeightCanMeasure(JNIEnv *env, jobject obj, bool measure)
2325 {
2326     WebView* view = GET_NATIVE_VIEW(env, obj);
2327     LOG_ASSERT(view, "view not set in nativeSetHeightCanMeasure");
2328     view->setHeightCanMeasure(measure);
2329 }
2330
2331 static jobject nativeGetCursorRingBounds(JNIEnv *env, jobject obj)
2332 {
2333     WebView* view = GET_NATIVE_VIEW(env, obj);
2334     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
2335     jclass rectClass = env->FindClass("android/graphics/Rect");
2336     LOG_ASSERT(rectClass, "Could not find Rect class!");
2337     jmethodID init = env->GetMethodID(rectClass, "<init>", "(IIII)V");
2338     LOG_ASSERT(init, "Could not find constructor for Rect");
2339     WebCore::IntRect webRect;
2340     view->cursorRingBounds(&webRect);
2341     jobject rect = env->NewObject(rectClass, init, webRect.x(),
2342         webRect.y(), webRect.maxX(), webRect.maxY());
2343     env->DeleteLocalRef(rectClass);
2344     return rect;
2345 }
2346
2347 static int nativeFindAll(JNIEnv *env, jobject obj, jstring findLower,
2348         jstring findUpper, jboolean sameAsLastSearch)
2349 {
2350     // If one or the other is null, do not search.
2351     if (!(findLower && findUpper))
2352         return 0;
2353     // Obtain the characters for both the lower case string and the upper case
2354     // string representing the same word.
2355     const jchar* findLowerChars = env->GetStringChars(findLower, 0);
2356     const jchar* findUpperChars = env->GetStringChars(findUpper, 0);
2357     // If one or the other is null, do not search.
2358     if (!(findLowerChars && findUpperChars)) {
2359         if (findLowerChars)
2360             env->ReleaseStringChars(findLower, findLowerChars);
2361         if (findUpperChars)
2362             env->ReleaseStringChars(findUpper, findUpperChars);
2363         checkException(env);
2364         return 0;
2365     }
2366     WebView* view = GET_NATIVE_VIEW(env, obj);
2367     LOG_ASSERT(view, "view not set in nativeFindAll");
2368     CachedRoot* root = view->getFrameCache(WebView::AllowNewer);
2369     if (!root) {
2370         env->ReleaseStringChars(findLower, findLowerChars);
2371         env->ReleaseStringChars(findUpper, findUpperChars);
2372         checkException(env);
2373         return 0;
2374     }
2375     int length = env->GetStringLength(findLower);
2376     // If the lengths of the strings do not match, then they are not the same
2377     // word, so do not search.
2378     if (!length || env->GetStringLength(findUpper) != length) {
2379         env->ReleaseStringChars(findLower, findLowerChars);
2380         env->ReleaseStringChars(findUpper, findUpperChars);
2381         checkException(env);
2382         return 0;
2383     }
2384     int width = root->documentWidth();
2385     int height = root->documentHeight();
2386     // Create a FindCanvas, which allows us to fake draw into it so we can
2387     // figure out where our search string is rendered (and how many times).
2388     FindCanvas canvas(width, height, (const UChar*) findLowerChars,
2389             (const UChar*) findUpperChars, length << 1);
2390     SkBitmap bitmap;
2391     bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
2392     canvas.setBitmapDevice(bitmap);
2393     root->draw(canvas);
2394     WTF::Vector<MatchInfo>* matches = canvas.detachMatches();
2395     // With setMatches, the WebView takes ownership of matches
2396     view->setMatches(matches, sameAsLastSearch);
2397
2398     env->ReleaseStringChars(findLower, findLowerChars);
2399     env->ReleaseStringChars(findUpper, findUpperChars);
2400     checkException(env);
2401     return canvas.found();
2402 }
2403
2404 static void nativeFindNext(JNIEnv *env, jobject obj, bool forward)
2405 {
2406     WebView* view = GET_NATIVE_VIEW(env, obj);
2407     LOG_ASSERT(view, "view not set in nativeFindNext");
2408     view->findNext(forward);
2409 }
2410
2411 static int nativeFindIndex(JNIEnv *env, jobject obj)
2412 {
2413     WebView* view = GET_NATIVE_VIEW(env, obj);
2414     LOG_ASSERT(view, "view not set in nativeFindIndex");
2415     return view->currentMatchIndex();
2416 }
2417
2418 static void nativeUpdateCachedTextfield(JNIEnv *env, jobject obj, jstring updatedText, jint generation)
2419 {
2420     WebView* view = GET_NATIVE_VIEW(env, obj);
2421     LOG_ASSERT(view, "view not set in nativeUpdateCachedTextfield");
2422     CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
2423     if (!root)
2424         return;
2425     const CachedNode* cachedFocusNode = root->currentFocus();
2426     if (!cachedFocusNode || !cachedFocusNode->isTextInput())
2427         return;
2428     WTF::String webcoreString = jstringToWtfString(env, updatedText);
2429     (const_cast<CachedNode*>(cachedFocusNode))->setExport(webcoreString);
2430     root->setTextGeneration(generation);
2431     checkException(env);
2432 }
2433
2434 static jint nativeGetBlockLeftEdge(JNIEnv *env, jobject obj, jint x, jint y,
2435         jfloat scale)
2436 {
2437     WebView* view = GET_NATIVE_VIEW(env, obj);
2438     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
2439     if (!view)
2440         return -1;
2441     return view->getBlockLeftEdge(x, y, scale);
2442 }
2443
2444 static void nativeDestroy(JNIEnv *env, jobject obj)
2445 {
2446     WebView* view = GET_NATIVE_VIEW(env, obj);
2447     LOGD("nativeDestroy view: %p", view);
2448     LOG_ASSERT(view, "view not set in nativeDestroy");
2449     delete view;
2450 }
2451
2452 static void nativeStopGL(JNIEnv *env, jobject obj)
2453 {
2454     GET_NATIVE_VIEW(env, obj)->stopGL();
2455 }
2456
2457 static bool nativeMoveCursorToNextTextInput(JNIEnv *env, jobject obj)
2458 {
2459     WebView* view = GET_NATIVE_VIEW(env, obj);
2460     CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
2461     if (!root)
2462         return false;
2463     const CachedNode* current = root->currentCursor();
2464     if (!current || !current->isTextInput())
2465         current = root->currentFocus();
2466     if (!current || !current->isTextInput())
2467         return false;
2468     const CachedFrame* frame;
2469     const CachedNode* next = root->nextTextField(current, &frame);
2470     if (!next)
2471         return false;
2472     const WebCore::IntRect& bounds = next->bounds(frame);
2473     root->rootHistory()->setMouseBounds(bounds);
2474     view->getWebViewCore()->updateCursorBounds(root, frame, next);
2475     view->showCursorUntimed();
2476     root->setCursor(const_cast<CachedFrame*>(frame),
2477             const_cast<CachedNode*>(next));
2478     view->sendMoveFocus(static_cast<WebCore::Frame*>(frame->framePointer()),
2479             static_cast<WebCore::Node*>(next->nodePointer()));
2480     if (!next->isInLayer())
2481         view->scrollRectOnScreen(bounds);
2482     view->getWebViewCore()->m_moveGeneration++;
2483     return true;
2484 }
2485
2486 static int nativeMoveGeneration(JNIEnv *env, jobject obj)
2487 {
2488     WebView* view = GET_NATIVE_VIEW(env, obj);
2489     if (!view)
2490         return 0;
2491     return view->moveGeneration();
2492 }
2493
2494 static void nativeMoveSelection(JNIEnv *env, jobject obj, int x, int y)
2495 {
2496     GET_NATIVE_VIEW(env, obj)->moveSelection(x, y);
2497 }
2498
2499 static void nativeResetSelection(JNIEnv *env, jobject obj)
2500 {
2501     return GET_NATIVE_VIEW(env, obj)->resetSelection();
2502 }
2503
2504 static jobject nativeSelectableText(JNIEnv* env, jobject obj)
2505 {
2506     IntPoint pos = GET_NATIVE_VIEW(env, obj)->selectableText();
2507     jclass pointClass = env->FindClass("android/graphics/Point");
2508     jmethodID init = env->GetMethodID(pointClass, "<init>", "(II)V");
2509     jobject point = env->NewObject(pointClass, init, pos.x(), pos.y());
2510     env->DeleteLocalRef(pointClass);
2511     return point;
2512 }
2513
2514 static void nativeSelectAll(JNIEnv* env, jobject obj)
2515 {
2516     GET_NATIVE_VIEW(env, obj)->selectAll();
2517 }
2518
2519 static void nativeSetExtendSelection(JNIEnv *env, jobject obj)
2520 {
2521     GET_NATIVE_VIEW(env, obj)->setExtendSelection();
2522 }
2523
2524 static jboolean nativeStartSelection(JNIEnv *env, jobject obj, int x, int y)
2525 {
2526     return GET_NATIVE_VIEW(env, obj)->startSelection(x, y);
2527 }
2528
2529 static jboolean nativeWordSelection(JNIEnv *env, jobject obj, int x, int y)
2530 {
2531     return GET_NATIVE_VIEW(env, obj)->wordSelection(x, y);
2532 }
2533
2534 static void nativeExtendSelection(JNIEnv *env, jobject obj, int x, int y)
2535 {
2536     GET_NATIVE_VIEW(env, obj)->extendSelection(x, y);
2537 }
2538
2539 static jobject nativeGetSelection(JNIEnv *env, jobject obj)
2540 {
2541     WebView* view = GET_NATIVE_VIEW(env, obj);
2542     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
2543     String selection = view->getSelection();
2544     return wtfStringToJstring(env, selection);
2545 }
2546
2547 static jboolean nativeHitSelection(JNIEnv *env, jobject obj, int x, int y)
2548 {
2549     return GET_NATIVE_VIEW(env, obj)->hitSelection(x, y);
2550 }
2551
2552 static jint nativeSelectionX(JNIEnv *env, jobject obj)
2553 {
2554     return GET_NATIVE_VIEW(env, obj)->selectionX();
2555 }
2556
2557 static jint nativeSelectionY(JNIEnv *env, jobject obj)
2558 {
2559     return GET_NATIVE_VIEW(env, obj)->selectionY();
2560 }
2561
2562 static void nativeSetSelectionPointer(JNIEnv *env, jobject obj, jint nativeView,
2563                                       jboolean set, jfloat scale, jint x, jint y)
2564 {
2565     ((WebView*)nativeView)->setSelectionPointer(set, scale, x, y);
2566 }
2567
2568 static void nativeRegisterPageSwapCallback(JNIEnv *env, jobject obj)
2569 {
2570     GET_NATIVE_VIEW(env, obj)->registerPageSwapCallback();
2571 }
2572
2573 static void nativeTileProfilingStart(JNIEnv *env, jobject obj)
2574 {
2575     TilesManager::instance()->getProfiler()->start();
2576 }
2577
2578 static float nativeTileProfilingStop(JNIEnv *env, jobject obj)
2579 {
2580     return TilesManager::instance()->getProfiler()->stop();
2581 }
2582
2583 static void nativeTileProfilingClear(JNIEnv *env, jobject obj)
2584 {
2585     TilesManager::instance()->getProfiler()->clear();
2586 }
2587
2588 static int nativeTileProfilingNumFrames(JNIEnv *env, jobject obj)
2589 {
2590     return TilesManager::instance()->getProfiler()->numFrames();
2591 }
2592
2593 static int nativeTileProfilingNumTilesInFrame(JNIEnv *env, jobject obj, int frame)
2594 {
2595     return TilesManager::instance()->getProfiler()->numTilesInFrame(frame);
2596 }
2597
2598 static int nativeTileProfilingGetInt(JNIEnv *env, jobject obj, int frame, int tile, jstring jkey)
2599 {
2600     WTF::String key = jstringToWtfString(env, jkey);
2601     TileProfileRecord* record = TilesManager::instance()->getProfiler()->getTile(frame, tile);
2602
2603     if (key == "left")
2604         return record->left;
2605     if (key == "top")
2606         return record->top;
2607     if (key == "right")
2608         return record->right;
2609     if (key == "bottom")
2610         return record->bottom;
2611     if (key == "level")
2612         return record->level;
2613     if (key == "isReady")
2614         return record->isReady ? 1 : 0;
2615     return -1;
2616 }
2617
2618 static float nativeTileProfilingGetFloat(JNIEnv *env, jobject obj, int frame, int tile, jstring jkey)
2619 {
2620     TileProfileRecord* record = TilesManager::instance()->getProfiler()->getTile(frame, tile);
2621     return record->scale;
2622 }
2623
2624 #ifdef ANDROID_DUMP_DISPLAY_TREE
2625 static void dumpToFile(const char text[], void* file) {
2626     fwrite(text, 1, strlen(text), reinterpret_cast<FILE*>(file));
2627     fwrite("\n", 1, 1, reinterpret_cast<FILE*>(file));
2628 }
2629 #endif
2630
2631 static bool nativeSetProperty(JNIEnv *env, jobject obj, jstring jkey, jstring jvalue)
2632 {
2633     WTF::String key = jstringToWtfString(env, jkey);
2634     WTF::String value = jstringToWtfString(env, jvalue);
2635     if (key == "inverted") {
2636         if (value == "true")
2637             TilesManager::instance()->setInvertedScreen(true);
2638         else
2639             TilesManager::instance()->setInvertedScreen(false);
2640         return true;
2641     }
2642     if (key == "inverted_contrast") {
2643         float contrast = value.toFloat();
2644         TilesManager::instance()->setInvertedScreenContrast(contrast);
2645         return true;
2646     }
2647     if (key == "enable_cpu_upload_path") {
2648         TilesManager::instance()->transferQueue()->setTextureUploadType(
2649             value == "true" ? CpuUpload : GpuUpload);
2650         return true;
2651     }
2652     return false;
2653 }
2654
2655 static jstring nativeGetProperty(JNIEnv *env, jobject obj, jstring key)
2656 {
2657     return 0;
2658 }
2659
2660 static void nativeOnTrimMemory(JNIEnv *env, jobject obj, jint level)
2661 {
2662     if (TilesManager::hardwareAccelerationEnabled()) {
2663         bool freeAllTextures = (level > TRIM_MEMORY_UI_HIDDEN);
2664         TilesManager::instance()->deallocateTextures(freeAllTextures);
2665     }
2666 }
2667
2668 static void nativeDumpDisplayTree(JNIEnv* env, jobject jwebview, jstring jurl)
2669 {
2670 #ifdef ANDROID_DUMP_DISPLAY_TREE
2671     WebView* view = GET_NATIVE_VIEW(env, jwebview);
2672     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
2673
2674     if (view && view->getWebViewCore()) {
2675         FILE* file = fopen(DISPLAY_TREE_LOG_FILE, "w");
2676         if (file) {
2677             SkFormatDumper dumper(dumpToFile, file);
2678             // dump the URL
2679             if (jurl) {
2680                 const char* str = env->GetStringUTFChars(jurl, 0);
2681                 SkDebugf("Dumping %s to %s\n", str, DISPLAY_TREE_LOG_FILE);
2682                 dumpToFile(str, file);
2683                 env->ReleaseStringUTFChars(jurl, str);
2684             }
2685             // now dump the display tree
2686             SkDumpCanvas canvas(&dumper);
2687             // this will playback the picture into the canvas, which will
2688             // spew its contents to the dumper
2689             view->draw(&canvas, 0, 0, false);
2690             // we're done with the file now
2691             fwrite("\n", 1, 1, file);
2692             fclose(file);
2693         }
2694 #if USE(ACCELERATED_COMPOSITING)
2695         const LayerAndroid* rootLayer = view->compositeRoot();
2696         if (rootLayer) {
2697           FILE* file = fopen(LAYERS_TREE_LOG_FILE,"w");
2698           if (file) {
2699               rootLayer->dumpLayers(file, 0);
2700               fclose(file);
2701           }
2702         }
2703 #endif
2704     }
2705 #endif
2706 }
2707
2708 static int nativeScrollableLayer(JNIEnv* env, jobject jwebview, jint x, jint y,
2709     jobject rect, jobject bounds)
2710 {
2711     WebView* view = GET_NATIVE_VIEW(env, jwebview);
2712     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
2713     SkIRect nativeRect, nativeBounds;
2714     int id = view->scrollableLayer(x, y, &nativeRect, &nativeBounds);
2715     if (rect)
2716         GraphicsJNI::irect_to_jrect(nativeRect, env, rect);
2717     if (bounds)
2718         GraphicsJNI::irect_to_jrect(nativeBounds, env, bounds);
2719     return id;
2720 }
2721
2722 static bool nativeScrollLayer(JNIEnv* env, jobject obj, jint layerId, jint x,
2723         jint y)
2724 {
2725 #if ENABLE(ANDROID_OVERFLOW_SCROLL)
2726     WebView* view = GET_NATIVE_VIEW(env, obj);
2727     LayerAndroid* root = view->compositeRoot();
2728     if (!root)
2729         return false;
2730     LayerAndroid* layer = root->findById(layerId);
2731     if (!layer || !layer->contentIsScrollable())
2732         return false;
2733     return static_cast<ScrollableLayerAndroid*>(layer)->scrollTo(x, y);
2734 #endif
2735     return false;
2736 }
2737
2738 static void nativeSetIsScrolling(JNIEnv* env, jobject jwebview, jboolean isScrolling)
2739 {
2740     WebView* view = GET_NATIVE_VIEW(env, jwebview);
2741     LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
2742     view->setIsScrolling(isScrolling);
2743 }
2744
2745 static void nativeUseHardwareAccelSkia(JNIEnv*, jobject, jboolean enabled)
2746 {
2747     BaseRenderer::setCurrentRendererType(enabled ? BaseRenderer::Ganesh : BaseRenderer::Raster);
2748 }
2749
2750 static int nativeGetBackgroundColor(JNIEnv* env, jobject obj)
2751 {
2752     WebView* view = GET_NATIVE_VIEW(env, obj);
2753     BaseLayerAndroid* baseLayer = view->getBaseLayer();
2754     if (baseLayer) {
2755         WebCore::Color color = baseLayer->getBackgroundColor();
2756         if (color.isValid())
2757             return SkColorSetARGB(color.alpha(), color.red(),
2758                                   color.green(), color.blue());
2759     }
2760     return SK_ColorWHITE;
2761 }
2762
2763 /*
2764  * JNI registration
2765  */
2766 static JNINativeMethod gJavaWebViewMethods[] = {
2767     { "nativeCacheHitFramePointer", "()I",
2768         (void*) nativeCacheHitFramePointer },
2769     { "nativeCacheHitIsPlugin", "()Z",
2770         (void*) nativeCacheHitIsPlugin },
2771     { "nativeCacheHitNodeBounds", "()Landroid/graphics/Rect;",
2772         (void*) nativeCacheHitNodeBounds },
2773     { "nativeCacheHitNodePointer", "()I",
2774         (void*) nativeCacheHitNodePointer },
2775     { "nativeClearCursor", "()V",
2776         (void*) nativeClearCursor },
2777     { "nativeCreate", "(ILjava/lang/String;)V",
2778         (void*) nativeCreate },
2779     { "nativeCursorFramePointer", "()I",
2780         (void*) nativeCursorFramePointer },
2781     { "nativePageShouldHandleShiftAndArrows", "()Z",
2782         (void*) nativePageShouldHandleShiftAndArrows },
2783     { "nativeCursorNodeBounds", "()Landroid/graphics/Rect;",
2784         (void*) nativeCursorNodeBounds },
2785     { "nativeCursorNodePointer", "()I",
2786         (void*) nativeCursorNodePointer },
2787     { "nativeCursorIntersects", "(Landroid/graphics/Rect;)Z",
2788         (void*) nativeCursorIntersects },
2789     { "nativeCursorIsAnchor", "()Z",
2790         (void*) nativeCursorIsAnchor },
2791     { "nativeCursorIsTextInput", "()Z",
2792         (void*) nativeCursorIsTextInput },
2793     { "nativeCursorPosition", "()Landroid/graphics/Point;",
2794         (void*) nativeCursorPosition },
2795     { "nativeCursorText", "()Ljava/lang/String;",
2796         (void*) nativeCursorText },
2797     { "nativeCursorWantsKeyEvents", "()Z",
2798         (void*)nativeCursorWantsKeyEvents },
2799     { "nativeDebugDump", "()V",
2800         (void*) nativeDebugDump },
2801     { "nativeDestroy", "()V",
2802         (void*) nativeDestroy },
2803     { "nativeDraw", "(Landroid/graphics/Canvas;IIZ)I",
2804         (void*) nativeDraw },
2805     { "nativeGetDrawGLFunction", "(ILandroid/graphics/Rect;Landroid/graphics/Rect;FI)I",
2806         (void*) nativeGetDrawGLFunction },
2807     { "nativeUpdateDrawGLFunction", "(Landroid/graphics/Rect;Landroid/graphics/Rect;)V",
2808         (void*) nativeUpdateDrawGLFunction },
2809     { "nativeDumpDisplayTree", "(Ljava/lang/String;)V",
2810         (void*) nativeDumpDisplayTree },
2811     { "nativeEvaluateLayersAnimations", "(I)Z",
2812         (void*) nativeEvaluateLayersAnimations },
2813     { "nativeExtendSelection", "(II)V",
2814         (void*) nativeExtendSelection },
2815     { "nativeFindAll", "(Ljava/lang/String;Ljava/lang/String;Z)I",
2816         (void*) nativeFindAll },
2817     { "nativeFindNext", "(Z)V",
2818         (void*) nativeFindNext },
2819     { "nativeFindIndex", "()I",
2820         (void*) nativeFindIndex},
2821     { "nativeFocusCandidateFramePointer", "()I",
2822         (void*) nativeFocusCandidateFramePointer },
2823     { "nativeFocusCandidateHasNextTextfield", "()Z",
2824         (void*) focusCandidateHasNextTextfield },
2825     { "nativeFocusCandidateIsPassword", "()Z",
2826         (void*) nativeFocusCandidateIsPassword },
2827     { "nativeFocusCandidateIsRtlText", "()Z",
2828         (void*) nativeFocusCandidateIsRtlText },
2829     { "nativeFocusCandidateIsTextInput", "()Z",
2830         (void*) nativeFocusCandidateIsTextInput },
2831     { "nativeFocusCandidateLineHeight", "()I",
2832         (void*) nativeFocusCandidateLineHeight },
2833     { "nativeFocusCandidateMaxLength", "()I",
2834         (void*) nativeFocusCandidateMaxLength },
2835     { "nativeFocusCandidateIsAutoComplete", "()Z",
2836         (void*) nativeFocusCandidateIsAutoComplete },
2837     { "nativeFocusCandidateIsSpellcheck", "()Z",
2838         (void*) nativeFocusCandidateIsSpellcheck },
2839     { "nativeFocusCandidateName", "()Ljava/lang/String;",
2840         (void*) nativeFocusCandidateName },
2841     { "nativeFocusCandidateNodeBounds", "()Landroid/graphics/Rect;",
2842         (void*) nativeFocusCandidateNodeBounds },
2843     { "nativeFocusCandidatePaddingRect", "()Landroid/graphics/Rect;",
2844         (void*) nativeFocusCandidatePaddingRect },
2845     { "nativeFocusCandidatePointer", "()I",
2846         (void*) nativeFocusCandidatePointer },
2847     { "nativeFocusCandidateText", "()Ljava/lang/String;",
2848         (void*) nativeFocusCandidateText },
2849     { "nativeFocusCandidateTextSize", "()F",
2850         (void*) nativeFocusCandidateTextSize },
2851     { "nativeFocusCandidateType", "()I",
2852         (void*) nativeFocusCandidateType },
2853     { "nativeFocusIsPlugin", "()Z",
2854         (void*) nativeFocusIsPlugin },
2855     { "nativeFocusNodeBounds", "()Landroid/graphics/Rect;",
2856         (void*) nativeFocusNodeBounds },
2857     { "nativeFocusNodePointer", "()I",
2858         (void*) nativeFocusNodePointer },
2859     { "nativeGetCursorRingBounds", "()Landroid/graphics/Rect;",
2860         (void*) nativeGetCursorRingBounds },
2861     { "nativeGetSelection", "()Ljava/lang/String;",
2862         (void*) nativeGetSelection },
2863     { "nativeHasCursorNode", "()Z",
2864         (void*) nativeHasCursorNode },
2865     { "nativeHasFocusNode", "()Z",
2866         (void*) nativeHasFocusNode },
2867     { "nativeHideCursor", "()V",
2868         (void*) nativeHideCursor },
2869     { "nativeHitSelection", "(II)Z",
2870         (void*) nativeHitSelection },
2871     { "nativeImageURI", "(II)Ljava/lang/String;",
2872         (void*) nativeImageURI },
2873     { "nativeInstrumentReport", "()V",
2874         (void*) nativeInstrumentReport },
2875     { "nativeLayerBounds", "(I)Landroid/graphics/Rect;",
2876         (void*) nativeLayerBounds },
2877     { "nativeMotionUp", "(III)Z",
2878         (void*) nativeMotionUp },
2879     { "nativeMoveCursor", "(IIZ)Z",
2880         (void*) nativeMoveCursor },
2881     { "nativeMoveCursorToNextTextInput", "()Z",
2882         (void*) nativeMoveCursorToNextTextInput },
2883     { "nativeMoveGeneration", "()I",
2884         (void*) nativeMoveGeneration },
2885     { "nativeMoveSelection", "(II)V",
2886         (void*) nativeMoveSelection },
2887     { "nativePointInNavCache", "(III)Z",
2888         (void*) nativePointInNavCache },
2889     { "nativeRecordButtons", "(IZZZ)V",
2890         (void*) nativeRecordButtons },
2891     { "nativeResetSelection", "()V",
2892         (void*) nativeResetSelection },
2893     { "nativeSelectableText", "()Landroid/graphics/Point;",
2894         (void*) nativeSelectableText },
2895     { "nativeSelectAll", "()V",
2896         (void*) nativeSelectAll },
2897     { "nativeSelectBestAt", "(Landroid/graphics/Rect;)V",
2898         (void*) nativeSelectBestAt },
2899     { "nativeSelectAt", "(II)V",
2900         (void*) nativeSelectAt },
2901     { "nativeSelectionX", "()I",
2902         (void*) nativeSelectionX },
2903     { "nativeSelectionY", "()I",
2904         (void*) nativeSelectionY },
2905     { "nativeSetExtendSelection", "()V",
2906         (void*) nativeSetExtendSelection },
2907     { "nativeSetFindIsEmpty", "()V",
2908         (void*) nativeSetFindIsEmpty },
2909     { "nativeSetFindIsUp", "(Z)V",
2910         (void*) nativeSetFindIsUp },
2911     { "nativeSetHeightCanMeasure", "(Z)V",
2912         (void*) nativeSetHeightCanMeasure },
2913     { "nativeSetBaseLayer", "(ILandroid/graphics/Region;ZZZ)V",
2914         (void*) nativeSetBaseLayer },
2915     { "nativeGetTextSelectionRegion", "(ILandroid/graphics/Region;)V",
2916         (void*) nativeGetTextSelectionRegion },
2917     { "nativeGetSelectionHandles", "(I[I)V",
2918         (void*) nativeGetSelectionHandles },
2919     { "nativeGetBaseLayer", "()I",
2920         (void*) nativeGetBaseLayer },
2921     { "nativeReplaceBaseContent", "(I)V",
2922         (void*) nativeReplaceBaseContent },
2923     { "nativeCopyBaseContentToPicture", "(Landroid/graphics/Picture;)V",
2924         (void*) nativeCopyBaseContentToPicture },
2925     { "nativeHasContent", "()Z",
2926         (void*) nativeHasContent },
2927     { "nativeSetSelectionPointer", "(IZFII)V",
2928         (void*) nativeSetSelectionPointer },
2929     { "nativeShowCursorTimed", "()V",
2930         (void*) nativeShowCursorTimed },
2931     { "nativeRegisterPageSwapCallback", "()V",
2932         (void*) nativeRegisterPageSwapCallback },
2933     { "nativeTileProfilingStart", "()V",
2934         (void*) nativeTileProfilingStart },
2935     { "nativeTileProfilingStop", "()F",
2936         (void*) nativeTileProfilingStop },
2937     { "nativeTileProfilingClear", "()V",
2938         (void*) nativeTileProfilingClear },
2939     { "nativeTileProfilingNumFrames", "()I",
2940         (void*) nativeTileProfilingNumFrames },
2941     { "nativeTileProfilingNumTilesInFrame", "(I)I",
2942         (void*) nativeTileProfilingNumTilesInFrame },
2943     { "nativeTileProfilingGetInt", "(IILjava/lang/String;)I",
2944         (void*) nativeTileProfilingGetInt },
2945     { "nativeTileProfilingGetFloat", "(IILjava/lang/String;)F",
2946         (void*) nativeTileProfilingGetFloat },
2947     { "nativeStartSelection", "(II)Z",
2948         (void*) nativeStartSelection },
2949     { "nativeStopGL", "()V",
2950         (void*) nativeStopGL },
2951     { "nativeSubtractLayers", "(Landroid/graphics/Rect;)Landroid/graphics/Rect;",
2952         (void*) nativeSubtractLayers },
2953     { "nativeTextGeneration", "()I",
2954         (void*) nativeTextGeneration },
2955     { "nativeUpdateCachedTextfield", "(Ljava/lang/String;I)V",
2956         (void*) nativeUpdateCachedTextfield },
2957     {  "nativeWordSelection", "(II)Z",
2958         (void*) nativeWordSelection },
2959     { "nativeGetBlockLeftEdge", "(IIF)I",
2960         (void*) nativeGetBlockLeftEdge },
2961     { "nativeScrollableLayer", "(IILandroid/graphics/Rect;Landroid/graphics/Rect;)I",
2962         (void*) nativeScrollableLayer },
2963     { "nativeScrollLayer", "(III)Z",
2964         (void*) nativeScrollLayer },
2965     { "nativeSetIsScrolling", "(Z)V",
2966         (void*) nativeSetIsScrolling },
2967     { "nativeUseHardwareAccelSkia", "(Z)V",
2968         (void*) nativeUseHardwareAccelSkia },
2969     { "nativeGetBackgroundColor", "()I",
2970         (void*) nativeGetBackgroundColor },
2971     { "nativeSetProperty", "(Ljava/lang/String;Ljava/lang/String;)Z",
2972         (void*) nativeSetProperty },
2973     { "nativeGetProperty", "(Ljava/lang/String;)Ljava/lang/String;",
2974         (void*) nativeGetProperty },
2975     { "nativeOnTrimMemory", "(I)V",
2976         (void*) nativeOnTrimMemory },
2977 };
2978
2979 int registerWebView(JNIEnv* env)
2980 {
2981     jclass clazz = env->FindClass("android/webkit/WebView");
2982     LOG_ASSERT(clazz, "Unable to find class android/webkit/WebView");
2983     gWebViewField = env->GetFieldID(clazz, "mNativeClass", "I");
2984     LOG_ASSERT(gWebViewField, "Unable to find android/webkit/WebView.mNativeClass");
2985     env->DeleteLocalRef(clazz);
2986
2987     return jniRegisterNativeMethods(env, "android/webkit/WebView", gJavaWebViewMethods, NELEM(gJavaWebViewMethods));
2988 }
2989
2990 } // namespace android