src/chrome/android/java/src/org/chromium/chrome/browser/ChromeBrowserProvider.java

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 package org.chromium.chrome.browser;
   6
   7 import android.app.Activity;
   8 import android.app.SearchManager;
   9 import android.content.ContentProvider;
  10 import android.content.ContentUris;
  11 import android.content.ContentValues;
  12 import android.content.Context;
  13 import android.content.Intent;
  14 import android.content.SharedPreferences;
  15 import android.content.UriMatcher;
  16 import android.database.Cursor;
  17 import android.database.MatrixCursor;
  18 import android.graphics.Bitmap;
  19 import android.net.Uri;
  20 import android.os.Binder;
  21 import android.os.Build;
  22 import android.os.Bundle;
  23 import android.os.Parcel;
  24 import android.os.Parcelable;
  25 import android.preference.PreferenceManager;
  26 import android.provider.BaseColumns;
  27 import android.provider.Browser;
  28 import android.provider.Browser.BookmarkColumns;
  29 import android.provider.Browser.SearchColumns;
  30 import android.text.TextUtils;
  31 import android.util.Log;
  32
  33 import com.google.common.annotations.VisibleForTesting;
  34
  35 import org.chromium.base.CalledByNative;
  36 import org.chromium.base.CalledByNativeUnchecked;
  37 import org.chromium.base.ThreadUtils;
  38 import org.chromium.chrome.browser.database.SQLiteCursor;
  39 import org.chromium.sync.notifier.SyncStatusHelper;
  40
  41 import java.util.ArrayList;
  42 import java.util.Arrays;
  43 import java.util.HashMap;
  44 import java.util.List;
  45 import java.util.Vector;
  46 import java.util.concurrent.atomic.AtomicBoolean;
  47
  48 /**
  49  * This class provides various information of Chrome, like bookmarks, most
  50  * visited page etc. It is used to support android.provider.Browser.
  51  *
  52  */
  53 public class ChromeBrowserProvider extends ContentProvider {
  54     private static final String TAG = "ChromeBrowserProvider";
  55
  56     // The permission required for using the bookmark folders API. Android build system does
  57     // not generate Manifest.java for java libraries, hence use the permission name string. When
  58     // making changes to this permission, also update the permission in AndroidManifest.xml.
  59     private static final String PERMISSION_READ_WRITE_BOOKMARKS = "READ_WRITE_BOOKMARK_FOLDERS";
  60
  61     // Defines the API methods that the Client can call by name.
  62     static final String CLIENT_API_BOOKMARK_NODE_EXISTS = "BOOKMARK_NODE_EXISTS";
  63     static final String CLIENT_API_CREATE_BOOKMARKS_FOLDER_ONCE = "CREATE_BOOKMARKS_FOLDER_ONCE";
  64     static final String CLIENT_API_GET_BOOKMARK_FOLDER_HIERARCHY = "GET_BOOKMARK_FOLDER_HIERARCHY";
  65     static final String CLIENT_API_GET_BOOKMARK_NODE = "GET_BOOKMARK_NODE";
  66     static final String CLIENT_API_GET_DEFAULT_BOOKMARK_FOLDER = "GET_DEFAULT_BOOKMARK_FOLDER";
  67     static final String CLIENT_API_GET_MOBILE_BOOKMARKS_FOLDER_ID =
  68             "GET_MOBILE_BOOKMARKS_FOLDER_ID";
  69     static final String CLIENT_API_IS_BOOKMARK_IN_MOBILE_BOOKMARKS_BRANCH =
  70             "IS_BOOKMARK_IN_MOBILE_BOOKMARKS_BRANCH";
  71     static final String CLIENT_API_DELETE_ALL_BOOKMARKS = "DELETE_ALL_BOOKMARKS";
  72     static final String CLIENT_API_RESULT_KEY = "result";
  73
  74
  75     // Defines Chrome's API authority, so it can be run and tested
  76     // independently.
  77     private static final String API_AUTHORITY_SUFFIX = ".browser";
  78
  79     private static final String BROWSER_CONTRACT_API_AUTHORITY =
  80         "com.google.android.apps.chrome.browser-contract";
  81
  82     // These values are taken from android.provider.BrowserContract.java since
  83     // that class is hidden from the SDK.
  84     private static final String BROWSER_CONTRACT_AUTHORITY = "com.android.browser";
  85     private static final String BROWSER_CONTRACT_HISTORY_CONTENT_TYPE =
  86         "vnd.android.cursor.dir/browser-history";
  87     private static final String BROWSER_CONTRACT_HISTORY_CONTENT_ITEM_TYPE =
  88         "vnd.android.cursor.item/browser-history";
  89
  90     // This Authority is for internal interface. It's concatenated with
  91     // Context.getPackageName() so that we can install different channels
  92     // SxS and have different authorities.
  93     private static final String AUTHORITY_SUFFIX = ".ChromeBrowserProvider";
  94     private static final String BOOKMARKS_PATH = "bookmarks";
  95     private static final String SEARCHES_PATH = "searches";
  96     private static final String HISTORY_PATH = "history";
  97     private static final String COMBINED_PATH = "combined";
  98     private static final String BOOKMARK_FOLDER_PATH = "hierarchy";
  99
 100     public static final Uri BROWSER_CONTRACTS_BOOKMAKRS_API_URI = buildContentUri(
 101             BROWSER_CONTRACT_API_AUTHORITY, BOOKMARKS_PATH);
 102
 103     public static final Uri BROWSER_CONTRACTS_SEARCHES_API_URI = buildContentUri(
 104             BROWSER_CONTRACT_API_AUTHORITY, SEARCHES_PATH);
 105
 106     public static final Uri BROWSER_CONTRACTS_HISTORY_API_URI = buildContentUri(
 107             BROWSER_CONTRACT_API_AUTHORITY, HISTORY_PATH);
 108
 109     public static final Uri BROWSER_CONTRACTS_COMBINED_API_URI = buildContentUri(
 110             BROWSER_CONTRACT_API_AUTHORITY, COMBINED_PATH);
 111
 112     /** The parameter used to specify a bookmark parent ID in ContentValues. */
 113     public static final String BOOKMARK_PARENT_ID_PARAM = "parentId";
 114
 115     /** The parameter used to specify whether this is a bookmark folder. */
 116     public static final String BOOKMARK_IS_FOLDER_PARAM = "isFolder";
 117
 118     /** Invalid id value for the Android ContentProvider API calls. */
 119     public static final long INVALID_CONTENT_PROVIDER_ID = 0;
 120
 121     // ID used to indicate an invalid id for bookmark nodes.
 122     // Client API queries should use ChromeBrowserProviderClient.INVALID_BOOKMARK_ID.
 123     static final long INVALID_BOOKMARK_ID = -1;
 124
 125     private static final String LAST_MODIFIED_BOOKMARK_FOLDER_ID_KEY = "last_bookmark_folder_id";
 126
 127     private static final int URI_MATCH_BOOKMARKS = 0;
 128     private static final int URI_MATCH_BOOKMARKS_ID = 1;
 129     private static final int URL_MATCH_API_BOOKMARK = 2;
 130     private static final int URL_MATCH_API_BOOKMARK_ID = 3;
 131     private static final int URL_MATCH_API_SEARCHES = 4;
 132     private static final int URL_MATCH_API_SEARCHES_ID = 5;
 133     private static final int URL_MATCH_API_HISTORY_CONTENT = 6;
 134     private static final int URL_MATCH_API_HISTORY_CONTENT_ID = 7;
 135     private static final int URL_MATCH_API_BOOKMARK_CONTENT = 8;
 136     private static final int URL_MATCH_API_BOOKMARK_CONTENT_ID = 9;
 137     private static final int URL_MATCH_BOOKMARK_SUGGESTIONS_ID = 10;
 138     private static final int URL_MATCH_BOOKMARK_HISTORY_SUGGESTIONS_ID = 11;
 139
 140     // TODO : Using Android.provider.Browser.HISTORY_PROJECTION once THUMBNAIL,
 141     // TOUCH_ICON, and USER_ENTERED fields are supported.
 142     private static final String[] BOOKMARK_DEFAULT_PROJECTION = new String[] {
 143             BookmarkColumns._ID, BookmarkColumns.URL, BookmarkColumns.VISITS,
 144             BookmarkColumns.DATE, BookmarkColumns.BOOKMARK, BookmarkColumns.TITLE,
 145             BookmarkColumns.FAVICON, BookmarkColumns.CREATED};
 146
 147     private static final String[] SUGGEST_PROJECTION = new String[] {
 148         BookmarkColumns._ID,
 149         BookmarkColumns.TITLE,
 150         BookmarkColumns.URL,
 151         BookmarkColumns.DATE,
 152         BookmarkColumns.BOOKMARK
 153     };
 154
 155     private final Object mInitializeUriMatcherLock = new Object();
 156     private final Object mLoadNativeLock = new Object();
 157     private UriMatcher mUriMatcher;
 158     private long mLastModifiedBookmarkFolderId = INVALID_BOOKMARK_ID;
 159     private int mNativeChromeBrowserProvider;
 160     private BookmarkNode mMobileBookmarksFolder;
 161
 162     /**
 163      * Records whether we've received a call to one of the public ContentProvider APIs.
 164      */
 165     protected boolean mContentProviderApiCalled;
 166
 167     private void ensureUriMatcherInitialized() {
 168         synchronized (mInitializeUriMatcherLock) {
 169             if (mUriMatcher != null) return;
 170
 171             mUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
 172             // The internal URIs
 173             String authority = getContext().getPackageName() + AUTHORITY_SUFFIX;
 174             mUriMatcher.addURI(authority, BOOKMARKS_PATH, URI_MATCH_BOOKMARKS);
 175             mUriMatcher.addURI(authority, BOOKMARKS_PATH + "/#", URI_MATCH_BOOKMARKS_ID);
 176             // The internal authority for public APIs
 177             String apiAuthority = getContext().getPackageName() + API_AUTHORITY_SUFFIX;
 178             mUriMatcher.addURI(apiAuthority, BOOKMARKS_PATH, URL_MATCH_API_BOOKMARK);
 179             mUriMatcher.addURI(apiAuthority, BOOKMARKS_PATH + "/#", URL_MATCH_API_BOOKMARK_ID);
 180             mUriMatcher.addURI(apiAuthority, SEARCHES_PATH, URL_MATCH_API_SEARCHES);
 181             mUriMatcher.addURI(apiAuthority, SEARCHES_PATH + "/#", URL_MATCH_API_SEARCHES_ID);
 182             mUriMatcher.addURI(apiAuthority, HISTORY_PATH, URL_MATCH_API_HISTORY_CONTENT);
 183             mUriMatcher.addURI(apiAuthority, HISTORY_PATH + "/#", URL_MATCH_API_HISTORY_CONTENT_ID);
 184             mUriMatcher.addURI(apiAuthority, COMBINED_PATH, URL_MATCH_API_BOOKMARK);
 185             mUriMatcher.addURI(apiAuthority, COMBINED_PATH + "/#", URL_MATCH_API_BOOKMARK_ID);
 186             // The internal authority for BrowserContracts
 187             mUriMatcher.addURI(BROWSER_CONTRACT_API_AUTHORITY, HISTORY_PATH,
 188                                URL_MATCH_API_HISTORY_CONTENT);
 189             mUriMatcher.addURI(BROWSER_CONTRACT_API_AUTHORITY, HISTORY_PATH + "/#",
 190                                URL_MATCH_API_HISTORY_CONTENT_ID);
 191             mUriMatcher.addURI(BROWSER_CONTRACT_API_AUTHORITY, COMBINED_PATH,
 192                                URL_MATCH_API_BOOKMARK);
 193             mUriMatcher.addURI(BROWSER_CONTRACT_API_AUTHORITY, COMBINED_PATH + "/#",
 194                                URL_MATCH_API_BOOKMARK_ID);
 195             mUriMatcher.addURI(BROWSER_CONTRACT_API_AUTHORITY, SEARCHES_PATH,
 196                                URL_MATCH_API_SEARCHES);
 197             mUriMatcher.addURI(BROWSER_CONTRACT_API_AUTHORITY, SEARCHES_PATH + "/#",
 198                                URL_MATCH_API_SEARCHES_ID);
 199             mUriMatcher.addURI(BROWSER_CONTRACT_API_AUTHORITY, BOOKMARKS_PATH,
 200                                URL_MATCH_API_BOOKMARK_CONTENT);
 201             mUriMatcher.addURI(BROWSER_CONTRACT_API_AUTHORITY, BOOKMARKS_PATH + "/#",
 202                                URL_MATCH_API_BOOKMARK_CONTENT_ID);
 203             // Added the Android Framework URIs, so the provider can easily switched
 204             // by adding 'browser' and 'com.android.browser' in manifest.
 205             // The Android's BrowserContract
 206             mUriMatcher.addURI(BROWSER_CONTRACT_AUTHORITY, HISTORY_PATH,
 207                                URL_MATCH_API_HISTORY_CONTENT);
 208             mUriMatcher.addURI(BROWSER_CONTRACT_AUTHORITY, HISTORY_PATH + "/#",
 209                                URL_MATCH_API_HISTORY_CONTENT_ID);
 210             mUriMatcher.addURI(BROWSER_CONTRACT_AUTHORITY, "combined", URL_MATCH_API_BOOKMARK);
 211             mUriMatcher.addURI(BROWSER_CONTRACT_AUTHORITY, "combined/#", URL_MATCH_API_BOOKMARK_ID);
 212             mUriMatcher.addURI(BROWSER_CONTRACT_AUTHORITY, SEARCHES_PATH, URL_MATCH_API_SEARCHES);
 213             mUriMatcher.addURI(BROWSER_CONTRACT_AUTHORITY, SEARCHES_PATH + "/#",
 214                                URL_MATCH_API_SEARCHES_ID);
 215             mUriMatcher.addURI(BROWSER_CONTRACT_AUTHORITY, BOOKMARKS_PATH,
 216                                URL_MATCH_API_BOOKMARK_CONTENT);
 217             mUriMatcher.addURI(BROWSER_CONTRACT_AUTHORITY, BOOKMARKS_PATH + "/#",
 218                                URL_MATCH_API_BOOKMARK_CONTENT_ID);
 219             // For supporting android.provider.browser.BookmarkColumns and
 220             // SearchColumns
 221             mUriMatcher.addURI("browser", BOOKMARKS_PATH, URL_MATCH_API_BOOKMARK);
 222             mUriMatcher.addURI("browser", BOOKMARKS_PATH + "/#", URL_MATCH_API_BOOKMARK_ID);
 223             mUriMatcher.addURI("browser", SEARCHES_PATH, URL_MATCH_API_SEARCHES);
 224             mUriMatcher.addURI("browser", SEARCHES_PATH + "/#", URL_MATCH_API_SEARCHES_ID);
 225
 226             mUriMatcher.addURI(apiAuthority,
 227                                BOOKMARKS_PATH + "/" + SearchManager.SUGGEST_URI_PATH_QUERY,
 228                                URL_MATCH_BOOKMARK_SUGGESTIONS_ID);
 229             mUriMatcher.addURI(apiAuthority,
 230                                SearchManager.SUGGEST_URI_PATH_QUERY,
 231                                URL_MATCH_BOOKMARK_HISTORY_SUGGESTIONS_ID);
 232         }
 233     }
 234
 235     @Override
 236     public boolean onCreate() {
 237         // Pre-load shared preferences object, this happens on a separate thread
 238         PreferenceManager.getDefaultSharedPreferences(getContext());
 239         return true;
 240     }
 241
 242     /**
 243      * Lazily fetches the last modified bookmark folder id.
 244      */
 245     private long getLastModifiedBookmarkFolderId() {
 246         if (mLastModifiedBookmarkFolderId == INVALID_BOOKMARK_ID) {
 247             SharedPreferences sharedPreferences =
 248                     PreferenceManager.getDefaultSharedPreferences(getContext());
 249             mLastModifiedBookmarkFolderId = sharedPreferences.getLong(
 250                     LAST_MODIFIED_BOOKMARK_FOLDER_ID_KEY, INVALID_BOOKMARK_ID);
 251         }
 252         return mLastModifiedBookmarkFolderId;
 253     }
 254
 255     private String buildSuggestWhere(String selection, int argc) {
 256         StringBuilder sb = new StringBuilder(selection);
 257         for (int i = 0; i < argc - 1; i++) {
 258             sb.append(" OR ");
 259             sb.append(selection);
 260         }
 261         return sb.toString();
 262     }
 263
 264     private String getReadWritePermissionNameForBookmarkFolders() {
 265         return getContext().getApplicationContext().getPackageName() + ".permission."
 266                 + PERMISSION_READ_WRITE_BOOKMARKS;
 267     }
 268
 269     private Cursor getBookmarkHistorySuggestions(String selection, String[] selectionArgs,
 270             String sortOrder, boolean excludeHistory) {
 271         boolean matchTitles = false;
 272         Vector<String> args = new Vector<String>();
 273         String like = selectionArgs[0] + "%";
 274         if (selectionArgs[0].startsWith("http") || selectionArgs[0].startsWith("file")) {
 275             args.add(like);
 276         } else {
 277             // Match against common URL prefixes.
 278             args.add("http://" + like);
 279             args.add("https://" + like);
 280             args.add("http://www." + like);
 281             args.add("https://www." + like);
 282             args.add("file://" + like);
 283             matchTitles = true;
 284         }
 285
 286         StringBuilder urlWhere = new StringBuilder("(");
 287         urlWhere.append(buildSuggestWhere(selection, args.size()));
 288         if (matchTitles) {
 289             args.add(like);
 290             urlWhere.append(" OR title LIKE ?");
 291         }
 292         urlWhere.append(")");
 293
 294         if (excludeHistory) {
 295             urlWhere.append(" AND bookmark=?");
 296             args.add("1");
 297         }
 298
 299         selectionArgs = args.toArray(selectionArgs);
 300         Cursor cursor = queryBookmarkFromAPI(SUGGEST_PROJECTION, urlWhere.toString(),
 301                 selectionArgs, sortOrder);
 302         return new ChromeBrowserProviderSuggestionsCursor(cursor);
 303     }
 304
 305     @Override
 306     public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
 307             String sortOrder) {
 308         if (!canHandleContentProviderApiCall()) return null;
 309
 310         // Check for invalid id values if provided.
 311         // If it represents a bookmark node then it's the root node. Don't provide access here.
 312         // Otherwise it represents a SQLite row id, so 0 is invalid.
 313         long bookmarkId = INVALID_CONTENT_PROVIDER_ID;
 314         try {
 315             bookmarkId = ContentUris.parseId(uri);
 316             if (bookmarkId == INVALID_CONTENT_PROVIDER_ID) return null;
 317         } catch (Exception e) {
 318         }
 319
 320         int match = mUriMatcher.match(uri);
 321         Cursor cursor = null;
 322         switch (match) {
 323             case URL_MATCH_BOOKMARK_SUGGESTIONS_ID:
 324                 cursor = getBookmarkHistorySuggestions(selection, selectionArgs, sortOrder, true);
 325                 break;
 326             case URL_MATCH_BOOKMARK_HISTORY_SUGGESTIONS_ID:
 327                 cursor = getBookmarkHistorySuggestions(selection, selectionArgs, sortOrder, false);
 328                 break;
 329             case URL_MATCH_API_BOOKMARK:
 330                 cursor = queryBookmarkFromAPI(projection, selection, selectionArgs, sortOrder);
 331                 break;
 332             case URL_MATCH_API_BOOKMARK_ID:
 333                 cursor = queryBookmarkFromAPI(projection, buildWhereClause(bookmarkId, selection),
 334                         selectionArgs, sortOrder);
 335                 break;
 336             case URL_MATCH_API_SEARCHES:
 337                 cursor = querySearchTermFromAPI(projection, selection, selectionArgs, sortOrder);
 338                 break;
 339             case URL_MATCH_API_SEARCHES_ID:
 340                 cursor = querySearchTermFromAPI(projection, buildWhereClause(bookmarkId, selection),
 341                         selectionArgs, sortOrder);
 342                 break;
 343             case URL_MATCH_API_HISTORY_CONTENT:
 344                 cursor = queryBookmarkFromAPI(projection, buildHistoryWhereClause(selection),
 345                         selectionArgs, sortOrder);
 346                 break;
 347             case URL_MATCH_API_HISTORY_CONTENT_ID:
 348                 cursor = queryBookmarkFromAPI(projection,
 349                         buildHistoryWhereClause(bookmarkId, selection), selectionArgs, sortOrder);
 350                 break;
 351             case URL_MATCH_API_BOOKMARK_CONTENT:
 352                 cursor = queryBookmarkFromAPI(projection, buildBookmarkWhereClause(selection),
 353                         selectionArgs, sortOrder);
 354                 break;
 355             case URL_MATCH_API_BOOKMARK_CONTENT_ID:
 356                 cursor = queryBookmarkFromAPI(projection,
 357                         buildBookmarkWhereClause(bookmarkId, selection), selectionArgs, sortOrder);
 358                 break;
 359             default:
 360                 throw new IllegalArgumentException(TAG + ": query - unknown URL uri = " + uri);
 361         }
 362         if (cursor == null) {
 363             cursor = new MatrixCursor(new String[] { });
 364         }
 365         cursor.setNotificationUri(getContext().getContentResolver(), uri);
 366         return cursor;
 367     }
 368
 369     @Override
 370     public Uri insert(Uri uri, ContentValues values) {
 371         if (!canHandleContentProviderApiCall()) return null;
 372
 373         int match = mUriMatcher.match(uri);
 374         Uri res = null;
 375         long id;
 376         switch (match) {
 377             case URI_MATCH_BOOKMARKS:
 378                 id = addBookmark(values);
 379                 if (id == INVALID_BOOKMARK_ID) return null;
 380                 break;
 381             case URL_MATCH_API_BOOKMARK_CONTENT:
 382                 values.put(BookmarkColumns.BOOKMARK, 1);
 383                 //$FALL-THROUGH$
 384             case URL_MATCH_API_BOOKMARK:
 385             case URL_MATCH_API_HISTORY_CONTENT:
 386                 id = addBookmarkFromAPI(values);
 387                 if (id == INVALID_CONTENT_PROVIDER_ID) return null;
 388                 break;
 389             case URL_MATCH_API_SEARCHES:
 390                 id = addSearchTermFromAPI(values);
 391                 if (id == INVALID_CONTENT_PROVIDER_ID) return null;
 392                 break;
 393             default:
 394                 throw new IllegalArgumentException(TAG + ": insert - unknown URL " + uri);
 395         }
 396
 397         res = ContentUris.withAppendedId(uri, id);
 398         getContext().getContentResolver().notifyChange(res, null);
 399         return res;
 400     }
 401
 402     @Override
 403     public int delete(Uri uri, String selection, String[] selectionArgs) {
 404         if (!canHandleContentProviderApiCall()) return 0;
 405
 406         // Check for invalid id values if provided.
 407         // If it represents a bookmark node then it's the root node and not mutable.
 408         // Otherwise it represents a SQLite row id, so 0 is invalid.
 409         long bookmarkId = INVALID_CONTENT_PROVIDER_ID;
 410         try {
 411             bookmarkId = ContentUris.parseId(uri);
 412             if (bookmarkId == INVALID_CONTENT_PROVIDER_ID) return 0;
 413         } catch (Exception e) {
 414         }
 415
 416         int match = mUriMatcher.match(uri);
 417         int result;
 418         switch (match) {
 419             case URI_MATCH_BOOKMARKS_ID :
 420                 result = nativeRemoveBookmark(mNativeChromeBrowserProvider, bookmarkId);
 421                 break;
 422             case URL_MATCH_API_BOOKMARK_ID:
 423                 result = removeBookmarkFromAPI(
 424                         buildWhereClause(bookmarkId, selection), selectionArgs);
 425                 break;
 426             case URL_MATCH_API_BOOKMARK:
 427                 result = removeBookmarkFromAPI(selection, selectionArgs);
 428                 break;
 429             case URL_MATCH_API_SEARCHES_ID:
 430                 result = removeSearchFromAPI(buildWhereClause(bookmarkId, selection),
 431                         selectionArgs);
 432                 break;
 433             case URL_MATCH_API_SEARCHES:
 434                 result = removeSearchFromAPI(selection, selectionArgs);
 435                 break;
 436             case URL_MATCH_API_HISTORY_CONTENT:
 437                 result = removeHistoryFromAPI(selection, selectionArgs);
 438                 break;
 439             case URL_MATCH_API_HISTORY_CONTENT_ID:
 440                 result = removeHistoryFromAPI(buildWhereClause(bookmarkId, selection),
 441                         selectionArgs);
 442                 break;
 443             case URL_MATCH_API_BOOKMARK_CONTENT:
 444                 result = removeBookmarkFromAPI(buildBookmarkWhereClause(selection), selectionArgs);
 445                 break;
 446             case URL_MATCH_API_BOOKMARK_CONTENT_ID:
 447                 result = removeBookmarkFromAPI(buildBookmarkWhereClause(bookmarkId, selection),
 448                         selectionArgs);
 449                 break;
 450             default:
 451                 throw new IllegalArgumentException(TAG + ": delete - unknown URL " + uri);
 452         }
 453         if (result != 0) {
 454             getContext().getContentResolver().notifyChange(uri, null);
 455         }
 456         return result;
 457     }
 458
 459     @Override
 460     public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
 461         if (!canHandleContentProviderApiCall()) return 0;
 462
 463         // Check for invalid id values if provided.
 464         // If it represents a bookmark node then it's the root node and not mutable.
 465         // Otherwise it represents a SQLite row id, so 0 is invalid.
 466         long bookmarkId = INVALID_CONTENT_PROVIDER_ID;
 467         try {
 468             bookmarkId = ContentUris.parseId(uri);
 469             if (bookmarkId == INVALID_CONTENT_PROVIDER_ID) return 0;
 470         } catch (Exception e) {
 471         }
 472
 473         int match = mUriMatcher.match(uri);
 474         int result;
 475         switch (match) {
 476             case URI_MATCH_BOOKMARKS_ID:
 477                 String url = null;
 478                 if (values.containsKey(Browser.BookmarkColumns.URL)) {
 479                     url = values.getAsString(Browser.BookmarkColumns.URL);
 480                 }
 481                 String title = values.getAsString(Browser.BookmarkColumns.TITLE);
 482                 long parentId = INVALID_BOOKMARK_ID;
 483                 if (values.containsKey(BOOKMARK_PARENT_ID_PARAM)) {
 484                     parentId = values.getAsLong(BOOKMARK_PARENT_ID_PARAM);
 485                 }
 486                 result = nativeUpdateBookmark(mNativeChromeBrowserProvider, bookmarkId, url, title,
 487                         parentId);
 488                 updateLastModifiedBookmarkFolder(parentId);
 489                 break;
 490             case URL_MATCH_API_BOOKMARK_ID:
 491                 result = updateBookmarkFromAPI(values, buildWhereClause(bookmarkId, selection),
 492                         selectionArgs);
 493                 break;
 494             case URL_MATCH_API_BOOKMARK:
 495                 result = updateBookmarkFromAPI(values, selection, selectionArgs);
 496                 break;
 497             case URL_MATCH_API_SEARCHES_ID:
 498                 result = updateSearchTermFromAPI(values, buildWhereClause(bookmarkId, selection),
 499                         selectionArgs);
 500                 break;
 501             case URL_MATCH_API_SEARCHES:
 502                 result = updateSearchTermFromAPI(values, selection, selectionArgs);
 503                 break;
 504             case URL_MATCH_API_HISTORY_CONTENT:
 505                 result = updateBookmarkFromAPI(values, buildHistoryWhereClause(selection),
 506                         selectionArgs);
 507                 break;
 508             case URL_MATCH_API_HISTORY_CONTENT_ID:
 509                 result = updateBookmarkFromAPI(values,
 510                         buildHistoryWhereClause(bookmarkId, selection), selectionArgs);
 511                 break;
 512             case URL_MATCH_API_BOOKMARK_CONTENT:
 513                 result = updateBookmarkFromAPI(values, buildBookmarkWhereClause(selection),
 514                         selectionArgs);
 515                 break;
 516             case URL_MATCH_API_BOOKMARK_CONTENT_ID:
 517                 result = updateBookmarkFromAPI(values,
 518                         buildBookmarkWhereClause(bookmarkId, selection), selectionArgs);
 519                 break;
 520             default:
 521                 throw new IllegalArgumentException(TAG + ": update - unknown URL " + uri);
 522         }
 523         if (result != 0) {
 524             getContext().getContentResolver().notifyChange(uri, null);
 525         }
 526         return result;
 527     }
 528
 529     @Override
 530     public String getType(Uri uri) {
 531         ensureUriMatcherInitialized();
 532         int match = mUriMatcher.match(uri);
 533         switch (match) {
 534             case URI_MATCH_BOOKMARKS:
 535             case URL_MATCH_API_BOOKMARK:
 536                 return "vnd.android.cursor.dir/bookmark";
 537             case URI_MATCH_BOOKMARKS_ID:
 538             case URL_MATCH_API_BOOKMARK_ID:
 539                 return "vnd.android.cursor.item/bookmark";
 540             case URL_MATCH_API_SEARCHES:
 541                 return "vnd.android.cursor.dir/searches";
 542             case URL_MATCH_API_SEARCHES_ID:
 543                 return "vnd.android.cursor.item/searches";
 544             case URL_MATCH_API_HISTORY_CONTENT:
 545                 return BROWSER_CONTRACT_HISTORY_CONTENT_TYPE;
 546             case URL_MATCH_API_HISTORY_CONTENT_ID:
 547                 return BROWSER_CONTRACT_HISTORY_CONTENT_ITEM_TYPE;
 548             default:
 549                 throw new IllegalArgumentException(TAG + ": getType - unknown URL " + uri);
 550         }
 551     }
 552
 553     private long addBookmark(ContentValues values) {
 554         String url = values.getAsString(Browser.BookmarkColumns.URL);
 555         String title = values.getAsString(Browser.BookmarkColumns.TITLE);
 556         boolean isFolder = false;
 557         if (values.containsKey(BOOKMARK_IS_FOLDER_PARAM)) {
 558             isFolder = values.getAsBoolean(BOOKMARK_IS_FOLDER_PARAM);
 559         }
 560         long parentId = INVALID_BOOKMARK_ID;
 561         if (values.containsKey(BOOKMARK_PARENT_ID_PARAM)) {
 562             parentId = values.getAsLong(BOOKMARK_PARENT_ID_PARAM);
 563         }
 564         long id = nativeAddBookmark(mNativeChromeBrowserProvider, url, title, isFolder, parentId);
 565         if (id == INVALID_BOOKMARK_ID) return id;
 566
 567         if (isFolder) {
 568             updateLastModifiedBookmarkFolder(id);
 569         } else {
 570             updateLastModifiedBookmarkFolder(parentId);
 571         }
 572         return id;
 573     }
 574
 575     private void updateLastModifiedBookmarkFolder(long id) {
 576         if (getLastModifiedBookmarkFolderId() == id) return;
 577
 578         mLastModifiedBookmarkFolderId = id;
 579         SharedPreferences sharedPreferences =
 580                 PreferenceManager.getDefaultSharedPreferences(getContext());
 581         sharedPreferences.edit()
 582                 .putLong(LAST_MODIFIED_BOOKMARK_FOLDER_ID_KEY, mLastModifiedBookmarkFolderId)
 583                 .apply();
 584     }
 585
 586     public static String getApiAuthority(Context context) {
 587         return context.getPackageName() + API_AUTHORITY_SUFFIX;
 588     }
 589
 590     public static String getInternalAuthority(Context context) {
 591         return context.getPackageName() + AUTHORITY_SUFFIX;
 592     }
 593
 594     public static Uri getBookmarksUri(Context context) {
 595         return buildContentUri(getInternalAuthority(context), BOOKMARKS_PATH);
 596     }
 597
 598     public static Uri getBookmarkFolderUri(Context context) {
 599         return buildContentUri(getInternalAuthority(context), BOOKMARK_FOLDER_PATH);
 600     }
 601
 602     public static Uri getBookmarksApiUri(Context context) {
 603         return buildContentUri(getApiAuthority(context), BOOKMARKS_PATH);
 604     }
 605
 606     public static Uri getSearchesApiUri(Context context) {
 607         return buildContentUri(getApiAuthority(context), SEARCHES_PATH);
 608     }
 609
 610     private boolean bookmarkNodeExists(long nodeId) {
 611         if (nodeId < 0) return false;
 612         return nativeBookmarkNodeExists(mNativeChromeBrowserProvider, nodeId);
 613     }
 614
 615     private long createBookmarksFolderOnce(String title, long parentId) {
 616         return nativeCreateBookmarksFolderOnce(mNativeChromeBrowserProvider, title, parentId);
 617     }
 618
 619     private BookmarkNode getBookmarkFolderHierarchy() {
 620         return nativeGetAllBookmarkFolders(mNativeChromeBrowserProvider);
 621     }
 622
 623     protected BookmarkNode getBookmarkNode(long nodeId, boolean getParent, boolean getChildren,
 624             boolean getFavicons, boolean getThumbnails) {
 625         // Don't allow going up the hierarchy if sync is disabled and the requested node
 626         // is the Mobile Bookmarks folder.
 627         if (getParent && nodeId == getMobileBookmarksFolderId()
 628                 && !SyncStatusHelper.get(getContext()).isSyncEnabled()) {
 629             getParent = false;
 630         }
 631
 632         BookmarkNode node = nativeGetBookmarkNode(mNativeChromeBrowserProvider, nodeId, getParent,
 633                 getChildren);
 634         if (!getFavicons && !getThumbnails) return node;
 635
 636         // Favicons and thumbnails need to be populated separately as they are provided
 637         // asynchronously by Chromium services other than the bookmark model.
 638         if (node.parent() != null) populateNodeImages(node.parent(), getFavicons, getThumbnails);
 639         for (BookmarkNode child : node.children()) {
 640             populateNodeImages(child, getFavicons, getThumbnails);
 641         }
 642
 643         return node;
 644     }
 645
 646     private BookmarkNode getDefaultBookmarkFolder() {
 647         // Try to access the bookmark folder last modified by us. If it doesn't exist anymore
 648         // then use the synced node (Mobile Bookmarks).
 649         BookmarkNode lastModified = getBookmarkNode(getLastModifiedBookmarkFolderId(), false, false,
 650                 false, false);
 651         if (lastModified == null) {
 652             lastModified = getMobileBookmarksFolder();
 653             mLastModifiedBookmarkFolderId = lastModified != null ? lastModified.id() :
 654                     INVALID_BOOKMARK_ID;
 655         }
 656         return lastModified;
 657     }
 658
 659     private void populateNodeImages(BookmarkNode node, boolean favicon, boolean thumbnail) {
 660         if (node == null || node.type() != Type.URL) return;
 661
 662         if (favicon) {
 663             node.setFavicon(nativeGetFaviconOrTouchIcon(mNativeChromeBrowserProvider, node.url()));
 664         }
 665
 666         if (thumbnail) {
 667             node.setThumbnail(nativeGetThumbnail(mNativeChromeBrowserProvider, node.url()));
 668         }
 669     }
 670
 671     private BookmarkNode getMobileBookmarksFolder() {
 672         if (mMobileBookmarksFolder == null) {
 673             mMobileBookmarksFolder = nativeGetMobileBookmarksFolder(mNativeChromeBrowserProvider);
 674         }
 675         return mMobileBookmarksFolder;
 676     }
 677
 678     protected long getMobileBookmarksFolderId() {
 679         BookmarkNode mobileBookmarks = getMobileBookmarksFolder();
 680         return mobileBookmarks != null ? mobileBookmarks.id() : INVALID_BOOKMARK_ID;
 681     }
 682
 683     private boolean isBookmarkInMobileBookmarksBranch(long nodeId) {
 684         if (nodeId <= 0) return false;
 685         return nativeIsBookmarkInMobileBookmarksBranch(mNativeChromeBrowserProvider, nodeId);
 686     }
 687
 688     static String argKey(int i) {
 689         return "arg" + i;
 690     }
 691
 692     @Override
 693     public Bundle call(String method, String arg, Bundle extras) {
 694         // TODO(shashishekhar): Refactor this code into a separate class.
 695         // Caller must have the READ_WRITE_BOOKMARK_FOLDERS permission.
 696         getContext().enforcePermission(getReadWritePermissionNameForBookmarkFolders(),
 697                                        Binder.getCallingPid(), Binder.getCallingUid(), TAG);
 698         if (!canHandleContentProviderApiCall()) return null;
 699         if (method == null || extras == null) return null;
 700
 701         Bundle result = new Bundle();
 702         if (CLIENT_API_BOOKMARK_NODE_EXISTS.equals(method)) {
 703             result.putBoolean(CLIENT_API_RESULT_KEY,
 704                     bookmarkNodeExists(extras.getLong(argKey(0))));
 705         } else if (CLIENT_API_CREATE_BOOKMARKS_FOLDER_ONCE.equals(method)) {
 706             result.putLong(CLIENT_API_RESULT_KEY,
 707                     createBookmarksFolderOnce(extras.getString(argKey(0)),
 708                                               extras.getLong(argKey(1))));
 709         } else if (CLIENT_API_GET_BOOKMARK_FOLDER_HIERARCHY.equals(method)) {
 710             result.putParcelable(CLIENT_API_RESULT_KEY, getBookmarkFolderHierarchy());
 711         } else if (CLIENT_API_GET_BOOKMARK_NODE.equals(method)) {
 712             result.putParcelable(CLIENT_API_RESULT_KEY,
 713                     getBookmarkNode(extras.getLong(argKey(0)),
 714                                     extras.getBoolean(argKey(1)),
 715                                     extras.getBoolean(argKey(2)),
 716                                     extras.getBoolean(argKey(3)),
 717                                     extras.getBoolean(argKey(4))));
 718         } else if (CLIENT_API_GET_DEFAULT_BOOKMARK_FOLDER.equals(method)) {
 719             result.putParcelable(CLIENT_API_RESULT_KEY, getDefaultBookmarkFolder());
 720         } else if (method.equals(CLIENT_API_GET_MOBILE_BOOKMARKS_FOLDER_ID)) {
 721             result.putLong(CLIENT_API_RESULT_KEY, getMobileBookmarksFolderId());
 722         } else if (CLIENT_API_IS_BOOKMARK_IN_MOBILE_BOOKMARKS_BRANCH.equals(method)) {
 723             result.putBoolean(CLIENT_API_RESULT_KEY,
 724                     isBookmarkInMobileBookmarksBranch(extras.getLong(argKey(0))));
 725         } else if(CLIENT_API_DELETE_ALL_BOOKMARKS.equals(method)) {
 726             nativeRemoveAllBookmarks(mNativeChromeBrowserProvider);
 727         } else {
 728             Log.w(TAG, "Received invalid method " + method);
 729             return null;
 730         }
 731
 732         return result;
 733     }
 734
 735     /**
 736      * Checks whether Chrome is sufficiently initialized to handle a call to the
 737      * ChromeBrowserProvider.
 738      */
 739     private boolean canHandleContentProviderApiCall() {
 740         mContentProviderApiCalled = true;
 741
 742         if (isInUiThread()) return false;
 743         if (!ensureNativeChromeLoaded()) return false;
 744         return true;
 745     }
 746
 747     /**
 748      * The type of a BookmarkNode.
 749      */
 750     public enum Type {
 751         URL,
 752         FOLDER,
 753         BOOKMARK_BAR,
 754         OTHER_NODE,
 755         MOBILE
 756     }
 757
 758     /**
 759      * Simple Data Object representing the chrome bookmark node.
 760      */
 761     public static class BookmarkNode implements Parcelable {
 762         private final long mId;
 763         private final String mName;
 764         private final String mUrl;
 765         private final Type mType;
 766         private final BookmarkNode mParent;
 767         private final List<BookmarkNode> mChildren = new ArrayList<BookmarkNode>();
 768
 769         // Favicon and thumbnail optionally set in a 2-step procedure.
 770         private byte[] mFavicon;
 771         private byte[] mThumbnail;
 772
 773         /** Used to pass structured data back from the native code. */
 774         @VisibleForTesting
 775         public BookmarkNode(long id, Type type, String name, String url, BookmarkNode parent) {
 776             mId = id;
 777             mName = name;
 778             mUrl = url;
 779             mType = type;
 780             mParent = parent;
 781         }
 782
 783         /**
 784          * @return The id of this bookmark entry.
 785          */
 786         public long id() {
 787             return mId;
 788         }
 789
 790         /**
 791          * @return The name of this bookmark entry.
 792          */
 793         public String name() {
 794             return mName;
 795         }
 796
 797         /**
 798          * @return The URL of this bookmark entry.
 799          */
 800         public String url() {
 801             return mUrl;
 802         }
 803
 804         /**
 805          * @return The type of this bookmark entry.
 806          */
 807         public Type type() {
 808             return mType;
 809         }
 810
 811         /**
 812          * @return The bookmark favicon, if any.
 813          */
 814         public byte[] favicon() {
 815             return mFavicon;
 816         }
 817
 818         /**
 819          * @return The bookmark thumbnail, if any.
 820          */
 821         public byte[] thumbnail() {
 822             return mThumbnail;
 823         }
 824
 825         /**
 826          * @return The parent folder of this bookmark entry.
 827          */
 828         public BookmarkNode parent() {
 829             return mParent;
 830         }
 831
 832         /**
 833          * Adds a child to this node.
 834          *
 835          * <p>
 836          * Used solely by the native code.
 837          */
 838         @VisibleForTesting
 839         @CalledByNativeUnchecked("BookmarkNode")
 840         public void addChild(BookmarkNode child) {
 841             mChildren.add(child);
 842         }
 843
 844         /**
 845          * @return The child bookmark nodes of this node.
 846          */
 847         public List<BookmarkNode> children() {
 848             return mChildren;
 849         }
 850
 851         /**
 852          * @return Whether this node represents a bookmarked URL or not.
 853          */
 854         public boolean isUrl() {
 855             return mUrl != null;
 856         }
 857
 858         /**
 859          * @return true if the two individual nodes contain the same information.
 860          * The existence of parent and children nodes is checked, but their contents are not.
 861          */
 862         public boolean equalContents(BookmarkNode node) {
 863             return node != null &&
 864                     mId == node.mId &&
 865                     !(mName == null ^ node.mName == null) &&
 866                     (mName == null || mName.equals(node.mName)) &&
 867                     !(mUrl == null ^ node.mUrl == null) &&
 868                     (mUrl == null || mUrl.equals(node.mUrl)) &&
 869                     mType == node.mType &&
 870                     byteArrayEqual(mFavicon, node.mFavicon) &&
 871                     byteArrayEqual(mThumbnail, node.mThumbnail) &&
 872                     !(mParent == null ^ node.mParent == null) &&
 873                     children().size() == node.children().size();
 874         }
 875
 876         private static boolean byteArrayEqual(byte[] byte1, byte[] byte2) {
 877             if (byte1 == null && byte2 != null) return byte2.length == 0;
 878             if (byte2 == null && byte1 != null) return byte1.length == 0;
 879             return Arrays.equals(byte1, byte2);
 880         }
 881
 882         @CalledByNative("BookmarkNode")
 883         private static BookmarkNode create(
 884                 long id, int type, String name, String url, BookmarkNode parent) {
 885             return new BookmarkNode(id, Type.values()[type], name, url, parent);
 886         }
 887
 888         @VisibleForTesting
 889         public void setFavicon(byte[] favicon) {
 890             mFavicon = favicon;
 891         }
 892
 893         @VisibleForTesting
 894         public void setThumbnail(byte[] thumbnail) {
 895             mThumbnail = thumbnail;
 896         }
 897
 898         @Override
 899         public int describeContents() {
 900             return 0;
 901         }
 902
 903         @Override
 904         public void writeToParcel(Parcel dest, int flags) {
 905             // Write the current node id.
 906             dest.writeLong(mId);
 907
 908             // Serialize the full hierarchy from the root.
 909             getHierarchyRoot().writeNodeContentsRecursive(dest);
 910         }
 911
 912         @VisibleForTesting
 913         public BookmarkNode getHierarchyRoot() {
 914             BookmarkNode root = this;
 915             while (root.parent() != null) {
 916                 root = root.parent();
 917             }
 918             return root;
 919         }
 920
 921         private void writeNodeContentsRecursive(Parcel dest) {
 922             writeNodeContents(dest);
 923             dest.writeInt(mChildren.size());
 924             for (BookmarkNode child : mChildren) {
 925                 child.writeNodeContentsRecursive(dest);
 926             }
 927         }
 928
 929         private void writeNodeContents(Parcel dest) {
 930             dest.writeLong(mId);
 931             dest.writeString(mName);
 932             dest.writeString(mUrl);
 933             dest.writeInt(mType.ordinal());
 934             dest.writeByteArray(mFavicon);
 935             dest.writeByteArray(mThumbnail);
 936             dest.writeLong(mParent != null ? mParent.mId : INVALID_BOOKMARK_ID);
 937         }
 938
 939         public static final Creator<BookmarkNode> CREATOR = new Creator<BookmarkNode>() {
 940             private HashMap<Long, BookmarkNode> mNodeMap;
 941
 942             @Override
 943             public BookmarkNode createFromParcel(Parcel source) {
 944                 mNodeMap = new HashMap<Long, BookmarkNode>();
 945                 long currentNodeId = source.readLong();
 946                 readNodeContentsRecursive(source);
 947                 BookmarkNode node = getNode(currentNodeId);
 948                 mNodeMap.clear();
 949                 return node;
 950             }
 951
 952             @Override
 953             public BookmarkNode[] newArray(int size) {
 954                 return new BookmarkNode[size];
 955             }
 956
 957             private BookmarkNode getNode(long id) {
 958                 if (id == INVALID_BOOKMARK_ID) return null;
 959                 Long nodeId = Long.valueOf(id);
 960                 if (!mNodeMap.containsKey(nodeId)) {
 961                     Log.e(TAG, "Invalid BookmarkNode hierarchy. Unknown id " + id);
 962                     return null;
 963                 }
 964                 return mNodeMap.get(nodeId);
 965             }
 966
 967             private BookmarkNode readNodeContents(Parcel source) {
 968                 long id = source.readLong();
 969                 String name = source.readString();
 970                 String url = source.readString();
 971                 int type = source.readInt();
 972                 byte[] favicon = source.createByteArray();
 973                 byte[] thumbnail = source.createByteArray();
 974                 long parentId = source.readLong();
 975                 if (type < 0 || type >= Type.values().length) {
 976                     Log.w(TAG, "Invalid node type ordinal value.");
 977                     return null;
 978                 }
 979
 980                 BookmarkNode node = new BookmarkNode(id, Type.values()[type], name, url,
 981                         getNode(parentId));
 982                 node.setFavicon(favicon);
 983                 node.setThumbnail(thumbnail);
 984                 return node;
 985             }
 986
 987             private BookmarkNode readNodeContentsRecursive(Parcel source) {
 988                 BookmarkNode node = readNodeContents(source);
 989                 if (node == null) return null;
 990
 991                 Long nodeId = Long.valueOf(node.id());
 992                 if (mNodeMap.containsKey(nodeId)) {
 993                     Log.e(TAG, "Invalid BookmarkNode hierarchy. Duplicate id " + node.id());
 994                     return null;
 995                 }
 996                 mNodeMap.put(nodeId, node);
 997
 998                 int numChildren = source.readInt();
 999                 for (int i = 0; i < numChildren; ++i) {
1000                     node.addChild(readNodeContentsRecursive(source));
1001                 }
1002
1003                 return node;
1004             }
1005         };
1006     }
1007
1008     private long addBookmarkFromAPI(ContentValues values) {
1009         BookmarkRow row = BookmarkRow.fromContentValues(values);
1010         if (row.url == null) {
1011             throw new IllegalArgumentException("Must have a bookmark URL");
1012         }
1013         return nativeAddBookmarkFromAPI(mNativeChromeBrowserProvider,
1014                 row.url, row.created, row.isBookmark, row.date, row.favicon,
1015                 row.title, row.visits, row.parentId);
1016     }
1017
1018     private Cursor queryBookmarkFromAPI(String[] projectionIn, String selection,
1019             String[] selectionArgs, String sortOrder) {
1020         String[] projection = null;
1021         if (projectionIn == null || projectionIn.length == 0) {
1022             projection = BOOKMARK_DEFAULT_PROJECTION;
1023         } else {
1024             projection = projectionIn;
1025         }
1026
1027         return nativeQueryBookmarkFromAPI(mNativeChromeBrowserProvider, projection, selection,
1028                 selectionArgs, sortOrder);
1029     }
1030
1031     private int updateBookmarkFromAPI(ContentValues values, String selection,
1032             String[] selectionArgs) {
1033         BookmarkRow row = BookmarkRow.fromContentValues(values);
1034         return nativeUpdateBookmarkFromAPI(mNativeChromeBrowserProvider,
1035                 row.url, row.created, row.isBookmark, row.date,
1036                 row.favicon, row.title, row.visits, row.parentId, selection, selectionArgs);
1037     }
1038
1039     private int removeBookmarkFromAPI(String selection, String[] selectionArgs) {
1040         return nativeRemoveBookmarkFromAPI(mNativeChromeBrowserProvider, selection, selectionArgs);
1041     }
1042
1043     private int removeHistoryFromAPI(String selection, String[] selectionArgs) {
1044         return nativeRemoveHistoryFromAPI(mNativeChromeBrowserProvider, selection, selectionArgs);
1045     }
1046
1047     @CalledByNative
1048     private void onBookmarkChanged() {
1049         getContext().getContentResolver().notifyChange(
1050                 buildAPIContentUri(getContext(), BOOKMARKS_PATH), null);
1051     }
1052
1053     @CalledByNative
1054     private void onSearchTermChanged() {
1055         getContext().getContentResolver().notifyChange(
1056                 buildAPIContentUri(getContext(), SEARCHES_PATH), null);
1057     }
1058
1059     private long addSearchTermFromAPI(ContentValues values) {
1060         SearchRow row = SearchRow.fromContentValues(values);
1061         if (row.term == null) {
1062             throw new IllegalArgumentException("Must have a search term");
1063         }
1064         return nativeAddSearchTermFromAPI(mNativeChromeBrowserProvider, row.term, row.date);
1065     }
1066
1067     private int updateSearchTermFromAPI(ContentValues values, String selection,
1068             String[] selectionArgs) {
1069         SearchRow row = SearchRow.fromContentValues(values);
1070         return nativeUpdateSearchTermFromAPI(mNativeChromeBrowserProvider,
1071                 row.term, row.date, selection, selectionArgs);
1072     }
1073
1074     private Cursor querySearchTermFromAPI(String[] projectionIn, String selection,
1075             String[] selectionArgs, String sortOrder) {
1076         String[] projection = null;
1077         if (projectionIn == null || projectionIn.length == 0) {
1078             projection = android.provider.Browser.SEARCHES_PROJECTION;
1079         } else {
1080             projection = projectionIn;
1081         }
1082         return nativeQuerySearchTermFromAPI(mNativeChromeBrowserProvider, projection, selection,
1083                 selectionArgs, sortOrder);
1084     }
1085
1086     private int removeSearchFromAPI(String selection, String[] selectionArgs) {
1087         return nativeRemoveSearchTermFromAPI(mNativeChromeBrowserProvider,
1088                 selection, selectionArgs);
1089     }
1090
1091     private static boolean isInUiThread() {
1092         if (!ThreadUtils.runningOnUiThread()) return false;
1093
1094         if (!"REL".equals(Build.VERSION.CODENAME)) {
1095             throw new IllegalStateException("Shouldn't run in the UI thread");
1096         }
1097
1098         Log.w(TAG, "ChromeBrowserProvider methods cannot be called from the UI thread.");
1099         return true;
1100     }
1101
1102     private static Uri buildContentUri(String authority, String path) {
1103         return Uri.parse("content://" + authority + "/" + path);
1104     }
1105
1106     private static Uri buildAPIContentUri(Context context, String path) {
1107         return buildContentUri(context.getPackageName() + API_AUTHORITY_SUFFIX, path);
1108     }
1109
1110     private static String buildWhereClause(long id, String selection) {
1111         StringBuffer sb = new StringBuffer();
1112         sb.append(BaseColumns._ID);
1113         sb.append(" = ");
1114         sb.append(id);
1115         if (!TextUtils.isEmpty(selection)) {
1116             sb.append(" AND (");
1117             sb.append(selection);
1118             sb.append(")");
1119         }
1120         return sb.toString();
1121     }
1122
1123     private static String buildHistoryWhereClause(long id, String selection) {
1124         return buildWhereClause(id, buildBookmarkWhereClause(selection, false));
1125     }
1126
1127     private static String buildHistoryWhereClause(String selection) {
1128         return buildBookmarkWhereClause(selection, false);
1129     }
1130
1131     /**
1132      * @return a SQL where class which is inserted the bookmark condition.
1133      */
1134     private static String buildBookmarkWhereClause(String selection, boolean is_bookmark) {
1135         StringBuffer sb = new StringBuffer();
1136         sb.append(BookmarkColumns.BOOKMARK);
1137         sb.append(is_bookmark ? " = 1 " : " = 0");
1138         if (!TextUtils.isEmpty(selection)) {
1139             sb.append(" AND (");
1140             sb.append(selection);
1141             sb.append(")");
1142         }
1143         return sb.toString();
1144     }
1145
1146     private static String buildBookmarkWhereClause(long id, String selection) {
1147         return buildWhereClause(id, buildBookmarkWhereClause(selection, true));
1148     }
1149
1150     private static String buildBookmarkWhereClause(String selection) {
1151         return buildBookmarkWhereClause(selection, true);
1152     }
1153
1154     // Wrap the value of BookmarkColumn.
1155     private static class BookmarkRow {
1156         Boolean isBookmark;
1157         Long created;
1158         String url;
1159         Long date;
1160         byte[] favicon;
1161         String title;
1162         Integer visits;
1163         long parentId;
1164
1165         static BookmarkRow fromContentValues(ContentValues values) {
1166             BookmarkRow row = new BookmarkRow();
1167             if (values.containsKey(BookmarkColumns.URL)) {
1168                 row.url = values.getAsString(BookmarkColumns.URL);
1169             }
1170             if (values.containsKey(BookmarkColumns.BOOKMARK)) {
1171                 row.isBookmark = values.getAsInteger(BookmarkColumns.BOOKMARK) != 0;
1172             }
1173             if (values.containsKey(BookmarkColumns.CREATED)) {
1174                 row.created = values.getAsLong(BookmarkColumns.CREATED);
1175             }
1176             if (values.containsKey(BookmarkColumns.DATE)) {
1177                 row.date = values.getAsLong(BookmarkColumns.DATE);
1178             }
1179             if (values.containsKey(BookmarkColumns.FAVICON)) {
1180                 row.favicon = values.getAsByteArray(BookmarkColumns.FAVICON);
1181                 // We need to know that the caller set the favicon column.
1182                 if (row.favicon == null) {
1183                     row.favicon = new byte[0];
1184                 }
1185             }
1186             if (values.containsKey(BookmarkColumns.TITLE)) {
1187                 row.title = values.getAsString(BookmarkColumns.TITLE);
1188             }
1189             if (values.containsKey(BookmarkColumns.VISITS)) {
1190                 row.visits = values.getAsInteger(BookmarkColumns.VISITS);
1191             }
1192             if (values.containsKey(BOOKMARK_PARENT_ID_PARAM)) {
1193                 row.parentId = values.getAsLong(BOOKMARK_PARENT_ID_PARAM);
1194             }
1195             return row;
1196         }
1197     }
1198
1199     // Wrap the value of SearchColumn.
1200     private static class SearchRow {
1201         String term;
1202         Long date;
1203
1204         static SearchRow fromContentValues(ContentValues values) {
1205             SearchRow row = new SearchRow();
1206             if (values.containsKey(SearchColumns.SEARCH)) {
1207                 row.term = values.getAsString(SearchColumns.SEARCH);
1208             }
1209             if (values.containsKey(SearchColumns.DATE)) {
1210                 row.date = values.getAsLong(SearchColumns.DATE);
1211             }
1212             return row;
1213         }
1214     }
1215
1216     /**
1217      * Returns true if the native side of the class is initialized.
1218      */
1219     protected boolean isNativeSideInitialized() {
1220         return mNativeChromeBrowserProvider != 0;
1221     }
1222
1223     /**
1224      * Make sure chrome is running. This method mustn't run on UI thread.
1225      *
1226      * @return Whether the native chrome process is running successfully once this has returned.
1227      */
1228     private boolean ensureNativeChromeLoaded() {
1229         ensureUriMatcherInitialized();
1230
1231         synchronized(mLoadNativeLock) {
1232             if (mNativeChromeBrowserProvider != 0) return true;
1233
1234             final AtomicBoolean retVal = new AtomicBoolean(true);
1235             ThreadUtils.runOnUiThreadBlocking(new Runnable() {
1236                 @Override
1237                 public void run() {
1238                     retVal.set(ensureNativeChromeLoadedOnUIThread());
1239                 }
1240             });
1241             return retVal.get();
1242         }
1243     }
1244
1245     /**
1246      * This method should only run on UI thread.
1247      */
1248     protected boolean ensureNativeChromeLoadedOnUIThread() {
1249         if (isNativeSideInitialized()) return true;
1250         mNativeChromeBrowserProvider = nativeInit();
1251         return isNativeSideInitialized();
1252     }
1253
1254     @Override
1255     protected void finalize() throws Throwable {
1256         try {
1257             // Tests might try to destroy this in the wrong thread.
1258             ThreadUtils.runOnUiThreadBlocking(new Runnable() {
1259                 @Override
1260                 public void run() {
1261                     ensureNativeChromeDestroyedOnUIThread();
1262                 }
1263             });
1264         } finally {
1265             super.finalize();
1266         }
1267     }
1268
1269     /**
1270      * This method should only run on UI thread.
1271      */
1272     private void ensureNativeChromeDestroyedOnUIThread() {
1273         if (isNativeSideInitialized()) {
1274             nativeDestroy(mNativeChromeBrowserProvider);
1275             mNativeChromeBrowserProvider = 0;
1276         }
1277     }
1278
1279     /**
1280      * Call to get the intent to create a bookmark shortcut on homescreen.
1281      */
1282     public static Intent getShortcutToBookmark(String url, String title, Bitmap favicon, int rValue,
1283             int gValue, int bValue, Context context) {
1284         return BookmarkUtils.createAddToHomeIntent(
1285                 context, url, title, favicon, rValue, gValue, bValue);
1286     }
1287
1288     private native int nativeInit();
1289     private native void nativeDestroy(int nativeChromeBrowserProvider);
1290
1291     // Public API native methods.
1292     private native long nativeAddBookmark(int nativeChromeBrowserProvider,
1293             String url, String title, boolean isFolder, long parentId);
1294
1295     private native int nativeRemoveBookmark(int nativeChromeBrowserProvider, long id);
1296
1297     private native int nativeUpdateBookmark(int nativeChromeBrowserProvider,
1298             long id, String url, String title, long parentId);
1299
1300     private native long nativeAddBookmarkFromAPI(int nativeChromeBrowserProvider,
1301             String url, Long created, Boolean isBookmark, Long date, byte[] favicon,
1302             String title, Integer visits, long parentId);
1303
1304     private native SQLiteCursor nativeQueryBookmarkFromAPI(int nativeChromeBrowserProvider,
1305             String[] projection, String selection, String[] selectionArgs, String sortOrder);
1306
1307     private native int nativeUpdateBookmarkFromAPI(int nativeChromeBrowserProvider,
1308             String url, Long created, Boolean isBookmark, Long date, byte[] favicon,
1309             String title, Integer visits, long parentId, String selection, String[] selectionArgs);
1310
1311     private native int nativeRemoveBookmarkFromAPI(int nativeChromeBrowserProvider,
1312             String selection, String[] selectionArgs);
1313
1314     private native int nativeRemoveHistoryFromAPI(int nativeChromeBrowserProvider,
1315             String selection, String[] selectionArgs);
1316
1317     private native long nativeAddSearchTermFromAPI(int nativeChromeBrowserProvider,
1318             String term, Long date);
1319
1320     private native SQLiteCursor nativeQuerySearchTermFromAPI(int nativeChromeBrowserProvider,
1321             String[] projection, String selection, String[] selectionArgs, String sortOrder);
1322
1323     private native int nativeUpdateSearchTermFromAPI(int nativeChromeBrowserProvider,
1324             String search, Long date, String selection, String[] selectionArgs);
1325
1326     private native int nativeRemoveSearchTermFromAPI(int nativeChromeBrowserProvider,
1327             String selection, String[] selectionArgs);
1328
1329     // Client API native methods.
1330     private native boolean nativeBookmarkNodeExists(int nativeChromeBrowserProvider, long id);
1331
1332     private native long nativeCreateBookmarksFolderOnce(int nativeChromeBrowserProvider,
1333             String title, long parentId);
1334
1335     private native BookmarkNode nativeGetAllBookmarkFolders(int nativeChromeBrowserProvider);
1336
1337     private native void nativeRemoveAllBookmarks(int nativeChromeBrowserProvider);
1338
1339     private native BookmarkNode nativeGetBookmarkNode(int nativeChromeBrowserProvider,
1340             long id, boolean getParent, boolean getChildren);
1341
1342     private native BookmarkNode nativeGetMobileBookmarksFolder(int nativeChromeBrowserProvider);
1343
1344     private native boolean nativeIsBookmarkInMobileBookmarksBranch(int nativeChromeBrowserProvider,
1345             long id);
1346
1347     private native byte[] nativeGetFaviconOrTouchIcon(int nativeChromeBrowserProvider, String url);
1348
1349     private native byte[] nativeGetThumbnail(int nativeChromeBrowserProvider, String url);
1350 }