Merge QPR1.180718.001

Conflicts:
	core/java/android/provider/Settings.java
	core/jni/android_view_InputEventReceiver.cpp
	core/res/res/values/config.xml
	core/res/res/values/symbols.xml
	media/jni/Android.bp
	packages/SettingsLib/src/com/android/settingslib/bluetooth/CachedBluetoothDevice.java
	packages/SettingsLib/tests/robotests/src/com/android/settingslib/fuelgauge/PowerWhitelistBackendTest.java
	packages/SystemUI/res/layout/status_bar_mobile_signal_group.xml
	packages/SystemUI/res/values/config.xml
	packages/SystemUI/src/com/android/keyguard/KeyguardConstants.java
	packages/SystemUI/src/com/android/systemui/statusbar/StatusBarMobileView.java
	services/core/java/com/android/server/ConnectivityService.java
	services/core/java/com/android/server/NetworkTimeUpdateService.java
	services/core/java/com/android/server/StorageManagerService.java
	services/core/java/com/android/server/Watchdog.java
	services/core/java/com/android/server/am/ActiveServices.java
	services/core/java/com/android/server/am/ActivityManagerService.java
	services/core/java/com/android/server/am/ActivityStack.java
	services/core/java/com/android/server/am/AppTaskImpl.java
	services/core/java/com/android/server/audio/AudioService.java
	services/core/java/com/android/server/wm/DisplayContent.java
	services/tests/uiservicestests/src/com/android/server/notification/NotificationRecordTest.java
	telephony/java/android/telephony/CarrierConfigManager.java
	telephony/java/android/telephony/ims/ImsReasonInfo.java
	telephony/java/android/telephony/ims/feature/MmTelFeature.java
	telephony/java/com/android/internal/telephony/ISmsBaseImpl.java

Change-Id: I3f98340699f9e31be03eaf23fdea70803c4cef42

1 files changed, 0 insertions, 559 deletions

diff --git a/libs/hwui/PathCache.cpp b/libs/hwui/PathCache.cpp
deleted file mode 100644
index e67c5bddd354..000000000000
--- a/libs/hwui/PathCache.cpp
+++ /dev/null
@@ -1,559 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <SkBitmap.h>
-#include <SkCanvas.h>
-#include <SkColor.h>
-#include <SkColorFilter.h>
-#include <SkMaskFilter.h>
-#include <SkPaint.h>
-#include <SkPath.h>
-#include <SkPathEffect.h>
-#include <SkRect.h>
-
-#include <utils/JenkinsHash.h>
-#include <utils/Trace.h>
-
-#include "Caches.h"
-#include "PathCache.h"
-
-#include "thread/Signal.h"
-#include "thread/TaskProcessor.h"
-
-#include <cutils/properties.h>
-
-namespace android {
-namespace uirenderer {
-
-static constexpr size_t PATH_CACHE_COUNT_LIMIT = 256;
-
-template <class T>
-static bool compareWidthHeight(const T& lhs, const T& rhs) {
-    return (lhs.mWidth == rhs.mWidth) && (lhs.mHeight == rhs.mHeight);
-}
-
-static bool compareRoundRects(const PathDescription::Shape::RoundRect& lhs,
-                              const PathDescription::Shape::RoundRect& rhs) {
-    return compareWidthHeight(lhs, rhs) && lhs.mRx == rhs.mRx && lhs.mRy == rhs.mRy;
-}
-
-static bool compareArcs(const PathDescription::Shape::Arc& lhs,
-                        const PathDescription::Shape::Arc& rhs) {
-    return compareWidthHeight(lhs, rhs) && lhs.mStartAngle == rhs.mStartAngle &&
-           lhs.mSweepAngle == rhs.mSweepAngle && lhs.mUseCenter == rhs.mUseCenter;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Cache entries
-///////////////////////////////////////////////////////////////////////////////
-
-PathDescription::PathDescription()
-        : type(ShapeType::None)
-        , join(SkPaint::kDefault_Join)
-        , cap(SkPaint::kDefault_Cap)
-        , style(SkPaint::kFill_Style)
-        , miter(4.0f)
-        , strokeWidth(1.0f)
-        , pathEffect(nullptr) {
-    // Shape bits should be set to zeroes, because they are used for hash calculation.
-    memset(&shape, 0, sizeof(Shape));
-}
-
-PathDescription::PathDescription(ShapeType type, const SkPaint* paint)
-        : type(type)
-        , join(paint->getStrokeJoin())
-        , cap(paint->getStrokeCap())
-        , style(paint->getStyle())
-        , miter(paint->getStrokeMiter())
-        , strokeWidth(paint->getStrokeWidth())
-        , pathEffect(paint->getPathEffect()) {
-    // Shape bits should be set to zeroes, because they are used for hash calculation.
-    memset(&shape, 0, sizeof(Shape));
-}
-
-hash_t PathDescription::hash() const {
-    uint32_t hash = JenkinsHashMix(0, static_cast<int>(type));
-    hash = JenkinsHashMix(hash, join);
-    hash = JenkinsHashMix(hash, cap);
-    hash = JenkinsHashMix(hash, style);
-    hash = JenkinsHashMix(hash, android::hash_type(miter));
-    hash = JenkinsHashMix(hash, android::hash_type(strokeWidth));
-    hash = JenkinsHashMix(hash, android::hash_type(pathEffect));
-    hash = JenkinsHashMixBytes(hash, (uint8_t*)&shape, sizeof(Shape));
-    return JenkinsHashWhiten(hash);
-}
-
-bool PathDescription::operator==(const PathDescription& rhs) const {
-    if (type != rhs.type) return false;
-    if (join != rhs.join) return false;
-    if (cap != rhs.cap) return false;
-    if (style != rhs.style) return false;
-    if (miter != rhs.miter) return false;
-    if (strokeWidth != rhs.strokeWidth) return false;
-    if (pathEffect != rhs.pathEffect) return false;
-    switch (type) {
-        case ShapeType::None:
-            return 0;
-        case ShapeType::Rect:
-            return compareWidthHeight(shape.rect, rhs.shape.rect);
-        case ShapeType::RoundRect:
-            return compareRoundRects(shape.roundRect, rhs.shape.roundRect);
-        case ShapeType::Circle:
-            return shape.circle.mRadius == rhs.shape.circle.mRadius;
-        case ShapeType::Oval:
-            return compareWidthHeight(shape.oval, rhs.shape.oval);
-        case ShapeType::Arc:
-            return compareArcs(shape.arc, rhs.shape.arc);
-        case ShapeType::Path:
-            return shape.path.mGenerationID == rhs.shape.path.mGenerationID;
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Utilities
-///////////////////////////////////////////////////////////////////////////////
-
-static void computePathBounds(const SkPath* path, const SkPaint* paint, PathTexture* texture,
-                              uint32_t& width, uint32_t& height) {
-    const SkRect& bounds = path->getBounds();
-    const float pathWidth = std::max(bounds.width(), 1.0f);
-    const float pathHeight = std::max(bounds.height(), 1.0f);
-
-    texture->left = floorf(bounds.fLeft);
-    texture->top = floorf(bounds.fTop);
-
-    texture->offset = (int)floorf(std::max(paint->getStrokeWidth(), 1.0f) * 1.5f + 0.5f);
-
-    width = uint32_t(pathWidth + texture->offset * 2.0 + 0.5);
-    height = uint32_t(pathHeight + texture->offset * 2.0 + 0.5);
-}
-
-static void initPaint(SkPaint& paint) {
-    // Make sure the paint is opaque, color, alpha, filter, etc.
-    // will be applied later when compositing the alpha8 texture
-    paint.setColor(SK_ColorBLACK);
-    paint.setAlpha(255);
-    paint.setColorFilter(nullptr);
-    paint.setMaskFilter(nullptr);
-    paint.setShader(nullptr);
-    paint.setBlendMode(SkBlendMode::kSrc);
-}
-
-static sk_sp<Bitmap> drawPath(const SkPath* path, const SkPaint* paint, PathTexture* texture,
-                              uint32_t maxTextureSize) {
-    uint32_t width, height;
-    computePathBounds(path, paint, texture, width, height);
-    if (width > maxTextureSize || height > maxTextureSize) {
-        ALOGW("Shape too large to be rendered into a texture (%dx%d, max=%dx%d)", width, height,
-              maxTextureSize, maxTextureSize);
-        return nullptr;
-    }
-
-    sk_sp<Bitmap> bitmap = Bitmap::allocateHeapBitmap(SkImageInfo::MakeA8(width, height));
-    SkPaint pathPaint(*paint);
-    initPaint(pathPaint);
-
-    SkBitmap skBitmap;
-    bitmap->getSkBitmap(&skBitmap);
-    skBitmap.eraseColor(0);
-    SkCanvas canvas(skBitmap);
-    canvas.translate(-texture->left + texture->offset, -texture->top + texture->offset);
-    canvas.drawPath(*path, pathPaint);
-    return bitmap;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Cache constructor/destructor
-///////////////////////////////////////////////////////////////////////////////
-
-PathCache::PathCache()
-        : mCache(LruCache<PathDescription, PathTexture*>::kUnlimitedCapacity)
-        , mSize(0)
-        , mMaxSize(DeviceInfo::multiplyByResolution(4)) {
-    mCache.setOnEntryRemovedListener(this);
-    mMaxTextureSize = DeviceInfo::get()->maxTextureSize();
-    mDebugEnabled = Properties::debugLevel & kDebugCaches;
-}
-
-PathCache::~PathCache() {
-    mCache.clear();
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Size management
-///////////////////////////////////////////////////////////////////////////////
-
-uint32_t PathCache::getSize() {
-    return mSize;
-}
-
-uint32_t PathCache::getMaxSize() {
-    return mMaxSize;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Callbacks
-///////////////////////////////////////////////////////////////////////////////
-
-void PathCache::operator()(PathDescription& entry, PathTexture*& texture) {
-    removeTexture(texture);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Caching
-///////////////////////////////////////////////////////////////////////////////
-
-void PathCache::removeTexture(PathTexture* texture) {
-    if (texture) {
-        const uint32_t size = texture->width() * texture->height();
-
-        // If there is a pending task we must wait for it to return
-        // before attempting our cleanup
-        const sp<PathTask>& task = texture->task();
-        if (task != nullptr) {
-            task->getResult();
-            texture->clearTask();
-        } else {
-            // If there is a pending task, the path was not added
-            // to the cache and the size wasn't increased
-            if (size > mSize) {
-                ALOGE("Removing path texture of size %d will leave "
-                      "the cache in an inconsistent state",
-                      size);
-            }
-            mSize -= size;
-        }
-
-        PATH_LOGD("PathCache::delete name, size, mSize = %d, %d, %d", texture->id, size, mSize);
-        if (mDebugEnabled) {
-            ALOGD("Shape deleted, size = %d", size);
-        }
-
-        texture->deleteTexture();
-        delete texture;
-    }
-}
-
-void PathCache::purgeCache(uint32_t width, uint32_t height) {
-    const uint32_t size = width * height;
-    // Don't even try to cache a bitmap that's bigger than the cache
-    if (size < mMaxSize) {
-        while (mSize + size > mMaxSize) {
-            mCache.removeOldest();
-        }
-    }
-}
-
-void PathCache::trim() {
-    while (mSize > mMaxSize || mCache.size() > PATH_CACHE_COUNT_LIMIT) {
-        LOG_ALWAYS_FATAL_IF(!mCache.size(),
-                            "Inconsistent mSize! Ran out of items to remove!"
-                            " mSize = %u, mMaxSize = %u",
-                            mSize, mMaxSize);
-        mCache.removeOldest();
-    }
-}
-
-PathTexture* PathCache::addTexture(const PathDescription& entry, const SkPath* path,
-                                   const SkPaint* paint) {
-    ATRACE_NAME("Generate Path Texture");
-
-    PathTexture* texture = new PathTexture(Caches::getInstance(), path->getGenerationID());
-    sk_sp<Bitmap> bitmap(drawPath(path, paint, texture, mMaxTextureSize));
-    if (!bitmap) {
-        delete texture;
-        return nullptr;
-    }
-
-    purgeCache(bitmap->width(), bitmap->height());
-    generateTexture(entry, *bitmap, texture);
-    return texture;
-}
-
-void PathCache::generateTexture(const PathDescription& entry, Bitmap& bitmap, PathTexture* texture,
-                                bool addToCache) {
-    generateTexture(bitmap, texture);
-
-    // Note here that we upload to a texture even if it's bigger than mMaxSize.
-    // Such an entry in mCache will only be temporary, since it will be evicted
-    // immediately on trim, or on any other Path entering the cache.
-    uint32_t size = texture->width() * texture->height();
-    mSize += size;
-    PATH_LOGD("PathCache::get/create: name, size, mSize = %d, %d, %d", texture->id, size, mSize);
-    if (mDebugEnabled) {
-        ALOGD("Shape created, size = %d", size);
-    }
-    if (addToCache) {
-        mCache.put(entry, texture);
-    }
-}
-
-void PathCache::clear() {
-    mCache.clear();
-}
-
-void PathCache::generateTexture(Bitmap& bitmap, Texture* texture) {
-    ATRACE_NAME("Upload Path Texture");
-    texture->upload(bitmap);
-    texture->setFilter(GL_LINEAR);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Path precaching
-///////////////////////////////////////////////////////////////////////////////
-
-PathCache::PathProcessor::PathProcessor(Caches& caches)
-        : TaskProcessor<sk_sp<Bitmap> >(&caches.tasks), mMaxTextureSize(caches.maxTextureSize) {}
-
-void PathCache::PathProcessor::onProcess(const sp<Task<sk_sp<Bitmap> > >& task) {
-    PathTask* t = static_cast<PathTask*>(task.get());
-    ATRACE_NAME("pathPrecache");
-
-    t->setResult(drawPath(&t->path, &t->paint, t->texture, mMaxTextureSize));
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Paths
-///////////////////////////////////////////////////////////////////////////////
-
-void PathCache::removeDeferred(const SkPath* path) {
-    Mutex::Autolock l(mLock);
-    mGarbage.push_back(path->getGenerationID());
-}
-
-void PathCache::clearGarbage() {
-    Vector<PathDescription> pathsToRemove;
-
-    {  // scope for the mutex
-        Mutex::Autolock l(mLock);
-        for (const uint32_t generationID : mGarbage) {
-            LruCache<PathDescription, PathTexture*>::Iterator iter(mCache);
-            while (iter.next()) {
-                const PathDescription& key = iter.key();
-                if (key.type == ShapeType::Path && key.shape.path.mGenerationID == generationID) {
-                    pathsToRemove.push(key);
-                }
-            }
-        }
-        mGarbage.clear();
-    }
-
-    for (size_t i = 0; i < pathsToRemove.size(); i++) {
-        mCache.remove(pathsToRemove.itemAt(i));
-    }
-}
-
-PathTexture* PathCache::get(const SkPath* path, const SkPaint* paint) {
-    PathDescription entry(ShapeType::Path, paint);
-    entry.shape.path.mGenerationID = path->getGenerationID();
-
-    PathTexture* texture = mCache.get(entry);
-
-    if (!texture) {
-        texture = addTexture(entry, path, paint);
-    } else {
-        // A bitmap is attached to the texture, this means we need to
-        // upload it as a GL texture
-        const sp<PathTask>& task = texture->task();
-        if (task != nullptr) {
-            // But we must first wait for the worker thread to be done
-            // producing the bitmap, so let's wait
-            sk_sp<Bitmap> bitmap = task->getResult();
-            if (bitmap) {
-                generateTexture(entry, *bitmap, texture, false);
-                texture->clearTask();
-            } else {
-                texture->clearTask();
-                texture = nullptr;
-                mCache.remove(entry);
-            }
-        }
-    }
-
-    return texture;
-}
-
-void PathCache::remove(const SkPath* path, const SkPaint* paint) {
-    PathDescription entry(ShapeType::Path, paint);
-    entry.shape.path.mGenerationID = path->getGenerationID();
-    mCache.remove(entry);
-}
-
-void PathCache::precache(const SkPath* path, const SkPaint* paint) {
-    if (!Caches::getInstance().tasks.canRunTasks()) {
-        return;
-    }
-
-    PathDescription entry(ShapeType::Path, paint);
-    entry.shape.path.mGenerationID = path->getGenerationID();
-
-    PathTexture* texture = mCache.get(entry);
-
-    bool generate = false;
-    if (!texture) {
-        generate = true;
-    }
-
-    if (generate) {
-        // It is important to specify the generation ID so we do not
-        // attempt to precache the same path several times
-        texture = new PathTexture(Caches::getInstance(), path->getGenerationID());
-        sp<PathTask> task = new PathTask(path, paint, texture);
-        texture->setTask(task);
-
-        // During the precaching phase we insert path texture objects into
-        // the cache that do not point to any GL texture. They are instead
-        // treated as a task for the precaching worker thread. This is why
-        // we do not check the cache limit when inserting these objects.
-        // The conversion into GL texture will happen in get(), when a client
-        // asks for a path texture. This is also when the cache limit will
-        // be enforced.
-        mCache.put(entry, texture);
-
-        if (mProcessor == nullptr) {
-            mProcessor = new PathProcessor(Caches::getInstance());
-        }
-        mProcessor->add(task);
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Rounded rects
-///////////////////////////////////////////////////////////////////////////////
-
-PathTexture* PathCache::getRoundRect(float width, float height, float rx, float ry,
-                                     const SkPaint* paint) {
-    PathDescription entry(ShapeType::RoundRect, paint);
-    entry.shape.roundRect.mWidth = width;
-    entry.shape.roundRect.mHeight = height;
-    entry.shape.roundRect.mRx = rx;
-    entry.shape.roundRect.mRy = ry;
-
-    PathTexture* texture = get(entry);
-
-    if (!texture) {
-        SkPath path;
-        SkRect r;
-        r.set(0.0f, 0.0f, width, height);
-        path.addRoundRect(r, rx, ry, SkPath::kCW_Direction);
-
-        texture = addTexture(entry, &path, paint);
-    }
-
-    return texture;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Circles
-///////////////////////////////////////////////////////////////////////////////
-
-PathTexture* PathCache::getCircle(float radius, const SkPaint* paint) {
-    PathDescription entry(ShapeType::Circle, paint);
-    entry.shape.circle.mRadius = radius;
-
-    PathTexture* texture = get(entry);
-
-    if (!texture) {
-        SkPath path;
-        path.addCircle(radius, radius, radius, SkPath::kCW_Direction);
-
-        texture = addTexture(entry, &path, paint);
-    }
-
-    return texture;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Ovals
-///////////////////////////////////////////////////////////////////////////////
-
-PathTexture* PathCache::getOval(float width, float height, const SkPaint* paint) {
-    PathDescription entry(ShapeType::Oval, paint);
-    entry.shape.oval.mWidth = width;
-    entry.shape.oval.mHeight = height;
-
-    PathTexture* texture = get(entry);
-
-    if (!texture) {
-        SkPath path;
-        SkRect r;
-        r.set(0.0f, 0.0f, width, height);
-        path.addOval(r, SkPath::kCW_Direction);
-
-        texture = addTexture(entry, &path, paint);
-    }
-
-    return texture;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Rects
-///////////////////////////////////////////////////////////////////////////////
-
-PathTexture* PathCache::getRect(float width, float height, const SkPaint* paint) {
-    PathDescription entry(ShapeType::Rect, paint);
-    entry.shape.rect.mWidth = width;
-    entry.shape.rect.mHeight = height;
-
-    PathTexture* texture = get(entry);
-
-    if (!texture) {
-        SkPath path;
-        SkRect r;
-        r.set(0.0f, 0.0f, width, height);
-        path.addRect(r, SkPath::kCW_Direction);
-
-        texture = addTexture(entry, &path, paint);
-    }
-
-    return texture;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Arcs
-///////////////////////////////////////////////////////////////////////////////
-
-PathTexture* PathCache::getArc(float width, float height, float startAngle, float sweepAngle,
-                               bool useCenter, const SkPaint* paint) {
-    PathDescription entry(ShapeType::Arc, paint);
-    entry.shape.arc.mWidth = width;
-    entry.shape.arc.mHeight = height;
-    entry.shape.arc.mStartAngle = startAngle;
-    entry.shape.arc.mSweepAngle = sweepAngle;
-    entry.shape.arc.mUseCenter = useCenter;
-
-    PathTexture* texture = get(entry);
-
-    if (!texture) {
-        SkPath path;
-        SkRect r;
-        r.set(0.0f, 0.0f, width, height);
-        if (useCenter) {
-            path.moveTo(r.centerX(), r.centerY());
-        }
-        path.arcTo(r, startAngle, sweepAngle, !useCenter);
-        if (useCenter) {
-            path.close();
-        }
-
-        texture = addTexture(entry, &path, paint);
-    }
-
-    return texture;
-}
-
-};  // namespace uirenderer
-};  // namespace android