path: root/Source/WebKit/android/WebCoreSupport/GeolocationPermissions.cpp

/*
 * Copyright 2009, The Android Open Source Project
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "GeolocationPermissions.h"

#include "WebViewCore.h"

#include <DOMWindow.h>
#include <Frame.h>
#include <Geolocation.h>
#include <Navigator.h>
#include <SQLiteDatabase.h>
#include <SQLiteFileSystem.h>
#include <SQLiteStatement.h>
#include <SQLiteTransaction.h>
#include <text/CString.h>

using namespace WebCore;

namespace android {

GeolocationPermissions::PermissionsMap GeolocationPermissions::s_permanentPermissions;
GeolocationPermissions::GeolocationPermissionsVector GeolocationPermissions::s_instances;
bool GeolocationPermissions::s_alwaysDeny = false;
bool GeolocationPermissions::s_permanentPermissionsLoaded = false;
bool GeolocationPermissions::s_permanentPermissionsModified = false;
String GeolocationPermissions::s_databasePath;

static const char* databaseName = "GeolocationPermissions.db";

GeolocationPermissions::GeolocationPermissions(WebViewCore* webViewCore)
    : m_webViewCore(webViewCore)
    , m_timer(this, &GeolocationPermissions::timerFired)

{
    ASSERT(m_webViewCore);
    maybeLoadPermanentPermissions();
    s_instances.append(this);
}

GeolocationPermissions::~GeolocationPermissions()
{
    size_t index = s_instances.find(this);
    s_instances.remove(index);
}

void GeolocationPermissions::queryPermissionState(Frame* frame)
{
    ASSERT(s_permanentPermissionsLoaded);

    // We use SecurityOrigin::toString to key the map. Note that testing
    // the SecurityOrigin pointer for equality is insufficient.
    String originString = frame->document()->securityOrigin()->toString();

    // If we've been told to always deny requests, do so.
    if (s_alwaysDeny) {
        makeAsynchronousCallbackToGeolocation(originString, false);
        return;
    }

    // See if we have a record for this origin in the permanent permissions.
    // These take precedence over temporary permissions so that changes made
    // from the browser settings work as intended.
    PermissionsMap::const_iterator iter = s_permanentPermissions.find(originString);
    PermissionsMap::const_iterator end = s_permanentPermissions.end();
    if (iter != end) {
        bool allow = iter->second;
        makeAsynchronousCallbackToGeolocation(originString, allow);
        return;
    }

    // Check the temporary permisions.
    iter = m_temporaryPermissions.find(originString);
    end = m_temporaryPermissions.end();
    if (iter != end) {
        bool allow = iter->second;
        makeAsynchronousCallbackToGeolocation(originString, allow);
        return;
    }

    // If there's no pending request, prompt the user.
    if (nextOriginInQueue().isEmpty()) {
        // Although multiple tabs may request permissions for the same origin
        // simultaneously, the routing in WebViewCore/CallbackProxy ensures that
        // the result of the request will make it back to this object, so
        // there's no need for a globally unique ID for the request.
        m_webViewCore->geolocationPermissionsShowPrompt(originString);
    }

    // Add this request to the queue so we can track which frames requested it.
    if (m_queuedOrigins.find(originString) == WTF::notFound) {
        m_queuedOrigins.append(originString);
        FrameSet frameSet;
        frameSet.add(frame);
        m_queuedOriginsToFramesMap.add(originString, frameSet);
    } else {
        ASSERT(m_queuedOriginsToFramesMap.contains(originString));
        m_queuedOriginsToFramesMap.find(originString)->second.add(frame);
    }
}

void GeolocationPermissions::cancelPermissionStateQuery(WebCore::Frame* frame)
{
    // We cancel any queued request for the given frame. There can be at most
    // one of these, since each frame maps to a single origin. We only cancel
    // the request if this frame is the only one reqesting permission for this
    // origin.
    //
    // We can use the origin string to avoid searching the map.
    String originString = frame->document()->securityOrigin()->toString();
    size_t index = m_queuedOrigins.find(originString);
    if (index == WTF::notFound)
        return;

    ASSERT(m_queuedOriginsToFramesMap.contains(originString));
    OriginToFramesMap::iterator iter = m_queuedOriginsToFramesMap.find(originString);
    ASSERT(iter->second.contains(frame));
    iter->second.remove(frame);
    if (!iter->second.isEmpty())
        return;

    m_queuedOrigins.remove(index);
    m_queuedOriginsToFramesMap.remove(iter);

    // If this is the origin currently being shown, cancel the prompt
    // and show the next in the queue, if present.
    if (index == 0) {
        m_webViewCore->geolocationPermissionsHidePrompt();
        if (!nextOriginInQueue().isEmpty())
            m_webViewCore->geolocationPermissionsShowPrompt(nextOriginInQueue());
    }
}

void GeolocationPermissions::makeAsynchronousCallbackToGeolocation(String origin, bool allow)
{
    m_callbackData.origin = origin;
    m_callbackData.allow = allow;
    m_timer.startOneShot(0);
}

void GeolocationPermissions::providePermissionState(String origin, bool allow, bool remember)
{
    ASSERT(s_permanentPermissionsLoaded);

    // It's possible that this method is called with an origin that doesn't
    // match m_originInProgress. This can occur if this object is reset
    // while a permission result is in the process of being marshalled back to
    // the WebCore thread from the browser. In this case, we simply ignore the
    // call.
    if (origin != nextOriginInQueue())
        return;

    maybeCallbackFrames(origin, allow);
    recordPermissionState(origin, allow, remember);

    // If the permissions are set to be remembered, cancel any queued requests
    // for this domain in other tabs.
    if (remember)
        cancelPendingRequestsInOtherTabs(origin);

    // Clear the origin from the queue.
    ASSERT(!m_queuedOrigins.isEmpty());
    m_queuedOrigins.remove(0);
    ASSERT(m_queuedOriginsToFramesMap.contains(origin));
    m_queuedOriginsToFramesMap.remove(origin);

    // If there are other requests queued, start the next one.
    if (!nextOriginInQueue().isEmpty())
        m_webViewCore->geolocationPermissionsShowPrompt(nextOriginInQueue());
}

void GeolocationPermissions::recordPermissionState(String origin, bool allow, bool remember)
{
    if (remember) {
        s_permanentPermissions.set(origin, allow);
        s_permanentPermissionsModified = true;
    } else {
        // It's possible that another tab recorded a permanent permission for
        // this origin while our request was in progress, but we record it
        // anyway.
        m_temporaryPermissions.set(origin, allow);
    }
}

void GeolocationPermissions::cancelPendingRequestsInOtherTabs(String origin)
{
    for (GeolocationPermissionsVector::const_iterator iter = s_instances.begin();
         iter != s_instances.end();
         ++iter)
        (*iter)->cancelPendingRequests(origin);
}

void GeolocationPermissions::cancelPendingRequests(String origin)
{
    size_t index = m_queuedOrigins.find(origin);

    // Don't cancel the request if it's currently being shown, in which case
    // it's at index 0.
    if (index == WTF::notFound || !index)
        return;

    // Get the permission from the permanent list.
    ASSERT(s_permanentPermissions.contains(origin));
    PermissionsMap::const_iterator iter = s_permanentPermissions.find(origin);
    bool allow = iter->second;

    maybeCallbackFrames(origin, allow);

    m_queuedOrigins.remove(index);
    ASSERT(m_queuedOriginsToFramesMap.contains(origin));
    m_queuedOriginsToFramesMap.remove(origin);
}

void GeolocationPermissions::timerFired(Timer<GeolocationPermissions>* timer)
{
    ASSERT_UNUSED(timer, timer == &m_timer);
    maybeCallbackFrames(m_callbackData.origin, m_callbackData.allow);
}

void GeolocationPermissions::resetTemporaryPermissionStates()
{
    ASSERT(s_permanentPermissionsLoaded);
    m_queuedOrigins.clear();
    m_queuedOriginsToFramesMap.clear();
    m_temporaryPermissions.clear();
    // If any permission results are being marshalled back to this thread, this
    // will render them inefective.
    m_timer.stop();

    m_webViewCore->geolocationPermissionsHidePrompt();
}

const WTF::String& GeolocationPermissions::nextOriginInQueue()
{
    static const String emptyString = "";
    return m_queuedOrigins.isEmpty() ? emptyString : m_queuedOrigins[0];
}

void GeolocationPermissions::maybeCallbackFrames(String origin, bool allow)
{
    // We can't track which frame issued the request, as frames can be deleted
    // or have their contents replaced. Even uniqueChildName is not unique when
    // frames are dynamically deleted and created. Instead, we simply call back
    // to the Geolocation object in all frames from the correct origin.
    for (Frame* frame = m_webViewCore->mainFrame(); frame; frame = frame->tree()->traverseNext()) {
        if (origin == frame->document()->securityOrigin()->toString()) {
            // If the page has changed, it may no longer have a Geolocation
            // object.
            Geolocation* geolocation = frame->domWindow()->navigator()->optionalGeolocation();
            if (geolocation)
                geolocation->setIsAllowed(allow);
        }
    }
}

GeolocationPermissions::OriginSet GeolocationPermissions::getOrigins()
{
    maybeLoadPermanentPermissions();
    OriginSet origins;
    PermissionsMap::const_iterator end = s_permanentPermissions.end();
    for (PermissionsMap::const_iterator iter = s_permanentPermissions.begin(); iter != end; ++iter)
        origins.add(iter->first);
    return origins;
}

bool GeolocationPermissions::getAllowed(String origin)
{
    maybeLoadPermanentPermissions();
    bool allowed = false;
    PermissionsMap::const_iterator iter = s_permanentPermissions.find(origin);
    PermissionsMap::const_iterator end = s_permanentPermissions.end();
    if (iter != end)
        allowed = iter->second;
    return allowed;
}

void GeolocationPermissions::clear(String origin)
{
    maybeLoadPermanentPermissions();
    PermissionsMap::iterator iter = s_permanentPermissions.find(origin);
    if (iter != s_permanentPermissions.end()) {
        s_permanentPermissions.remove(iter);
        s_permanentPermissionsModified = true;
    }
}

void GeolocationPermissions::allow(String origin)
{
    maybeLoadPermanentPermissions();
    // We replace any existing permanent permission.
    s_permanentPermissions.set(origin, true);
    s_permanentPermissionsModified = true;
}

void GeolocationPermissions::clearAll()
{
    maybeLoadPermanentPermissions();
    s_permanentPermissions.clear();
    s_permanentPermissionsModified = true;
}

void GeolocationPermissions::maybeLoadPermanentPermissions()
{
    if (s_permanentPermissionsLoaded)
        return;
    s_permanentPermissionsLoaded = true;

    SQLiteDatabase database;
    if (!openDatabase(&database))
        return;

    // Create the table here, such that even if we've just created the DB, the
    // commands below should succeed.
    if (!database.executeCommand("CREATE TABLE IF NOT EXISTS Permissions (origin TEXT UNIQUE NOT NULL, allow INTEGER NOT NULL)")) {
        database.close();
        return;
    }

    SQLiteStatement statement(database, "SELECT * FROM Permissions");
    if (statement.prepare() != SQLResultOk) {
        database.close();
        return;
    }

    ASSERT(s_permanentPermissions.size() == 0);
    while (statement.step() == SQLResultRow)
        s_permanentPermissions.set(statement.getColumnText(0), statement.getColumnInt64(1));

    database.close();
}

void GeolocationPermissions::maybeStorePermanentPermissions()
{
    // If the permanent permissions haven't been modified, there's no need to
    // save them to the DB. (If we haven't even loaded them, writing them now
    // would overwrite the stored permissions with the empty set.)
    if (!s_permanentPermissionsModified)
        return;

    SQLiteDatabase database;
    if (!openDatabase(&database))
        return;

    SQLiteTransaction transaction(database);

    // The number of entries should be small enough that it's not worth trying
    // to perform a diff. Simply clear the table and repopulate it.
    if (!database.executeCommand("DELETE FROM Permissions")) {
        database.close();
        return;
    }

    PermissionsMap::const_iterator end = s_permanentPermissions.end();
    for (PermissionsMap::const_iterator iter = s_permanentPermissions.begin(); iter != end; ++iter) {
         SQLiteStatement statement(database, "INSERT INTO Permissions (origin, allow) VALUES (?, ?)");
         if (statement.prepare() != SQLResultOk)
             continue;
         statement.bindText(1, iter->first);
         statement.bindInt64(2, iter->second);
         statement.executeCommand();
    }

    transaction.commit();
    database.close();

    s_permanentPermissionsModified = false;
}

void GeolocationPermissions::setDatabasePath(String path)
{
    // Take the first non-empty value.
    if (s_databasePath.length() > 0)
        return;
    s_databasePath = path;
}

bool GeolocationPermissions::openDatabase(SQLiteDatabase* database)
{
    ASSERT(database);
    String filename = SQLiteFileSystem::appendDatabaseFileNameToPath(s_databasePath, databaseName);
    if (!database->open(filename))
        return false;
    if (chmod(filename.utf8().data(), S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP)) {
        database->close();
        return false;
    }
    return true;
}

void GeolocationPermissions::setAlwaysDeny(bool deny)
{
    s_alwaysDeny = deny;
}

}  // namespace android