Revert "Mark layers with color transform client composition if not implemented."

This reverts commit c53ea9f5f8e8d30ad79618d57b965a492962b546.

Reason for revert: Breaks some display output
Bug: 129945273
Bug: 115554640

Merged-In: If70a148ae6ad673b5dd03143b3f1ed73eaa1290f
Change-Id: If70a148ae6ad673b5dd03143b3f1ed73eaa1290f
(cherry picked from commit 6f5a48f7af9de2c7cb69ac14a8a8666617f27d21)
diff --git a/graphics/composer/2.1/utils/passthrough/include/composer-passthrough/2.1/HwcHal.h b/graphics/composer/2.1/utils/passthrough/include/composer-passthrough/2.1/HwcHal.h
index 5826b12..436e461 100644
--- a/graphics/composer/2.1/utils/passthrough/include/composer-passthrough/2.1/HwcHal.h
+++ b/graphics/composer/2.1/utils/passthrough/include/composer-passthrough/2.1/HwcHal.h
@@ -162,7 +162,6 @@
 
     Error destroyLayer(Display display, Layer layer) override {
         int32_t err = mDispatch.destroyLayer(mDevice, display, layer);
-        onLayerDestroyed(display, layer);
         return static_cast<Error>(err);
     }
 
@@ -328,7 +327,6 @@
                           std::vector<IComposerClient::Composition>* outCompositionTypes,
                           uint32_t* outDisplayRequestMask, std::vector<Layer>* outRequestedLayers,
                           std::vector<uint32_t>* outRequestMasks) override {
-        onBeforeValidateDisplay(display);
         uint32_t typesCount = 0;
         uint32_t reqsCount = 0;
         int32_t err = mDispatch.validateDisplay(mDevice, display, &typesCount, &reqsCount);
@@ -337,15 +335,17 @@
             return static_cast<Error>(err);
         }
 
-        err = getChangedCompositionTypes(display, &typesCount, nullptr, nullptr);
+        err = mDispatch.getChangedCompositionTypes(mDevice, display, &typesCount, nullptr, nullptr);
         if (err != HWC2_ERROR_NONE) {
             return static_cast<Error>(err);
         }
 
         std::vector<Layer> changedLayers(typesCount);
         std::vector<IComposerClient::Composition> compositionTypes(typesCount);
-        err = getChangedCompositionTypes(display, &typesCount, changedLayers.data(),
-                                         compositionTypes.data());
+        err = mDispatch.getChangedCompositionTypes(
+            mDevice, display, &typesCount, changedLayers.data(),
+            reinterpret_cast<std::underlying_type<IComposerClient::Composition>::type*>(
+                compositionTypes.data()));
         if (err != HWC2_ERROR_NONE) {
             return static_cast<Error>(err);
         }
@@ -578,15 +578,6 @@
         return true;
     }
 
-    virtual int32_t getChangedCompositionTypes(Display display, uint32_t* outTypesCount,
-                                               Layer* outChangedLayers,
-                                               IComposerClient::Composition* outCompositionTypes) {
-        return getChangedCompositionTypesInternal(display, outTypesCount, outChangedLayers,
-                                                  outCompositionTypes);
-    }
-    virtual void onLayerDestroyed(Display /* display */, Layer /* layer */) {}
-    virtual void onBeforeValidateDisplay(Display /* display */) {}
-
     static void hotplugHook(hwc2_callback_data_t callbackData, hwc2_display_t display,
                             int32_t connected) {
         auto hal = static_cast<HwcHalImpl*>(callbackData);
@@ -605,15 +596,6 @@
         hal->mEventCallback->onVsync(display, timestamp);
     }
 
-    int32_t getChangedCompositionTypesInternal(Display display, uint32_t* outTypesCount,
-                                               Layer* outChangedLayers,
-                                               IComposerClient::Composition* outCompositionTypes) {
-        return mDispatch.getChangedCompositionTypes(
-                mDevice, display, outTypesCount, outChangedLayers,
-                reinterpret_cast<std::underlying_type<IComposerClient::Composition>::type*>(
-                        outCompositionTypes));
-    }
-
     hwc2_device_t* mDevice = nullptr;
 
     std::unordered_set<hwc2_capability_t> mCapabilities;
diff --git a/graphics/composer/2.3/utils/passthrough/include/composer-passthrough/2.3/HwcHal.h b/graphics/composer/2.3/utils/passthrough/include/composer-passthrough/2.3/HwcHal.h
index 9d67e04..070cf80 100644
--- a/graphics/composer/2.3/utils/passthrough/include/composer-passthrough/2.3/HwcHal.h
+++ b/graphics/composer/2.3/utils/passthrough/include/composer-passthrough/2.3/HwcHal.h
@@ -42,20 +42,6 @@
 using V2_1::Display;
 using V2_1::Error;
 
-namespace {
-
-bool isIdentityMatrix(const float* matrix) {
-    if (matrix[0] == 1.0 && matrix[1] == 0.0 && matrix[2] == 0.0 && matrix[3] == 0.0 &&
-        matrix[4] == 0.0 && matrix[5] == 1.0 && matrix[6] == 0.0 && matrix[7] == 0.0 &&
-        matrix[8] == 0.0 && matrix[9] == 0.0 && matrix[10] == 1.0 && matrix[11] == 0.0 &&
-        matrix[12] == 0.0 && matrix[13] == 0.0 && matrix[14] == 0.0 && matrix[15] == 1.0) {
-        return true;
-    }
-    return false;
-}
-
-}  // namespace
-
 // HwcHalImpl implements V2_*::hal::ComposerHal on top of hwcomposer2
 template <typename Hal>
 class HwcHalImpl : public V2_2::passthrough::detail::HwcHalImpl<Hal> {
@@ -144,16 +130,6 @@
 
     Error setLayerColorTransform(Display display, Layer layer, const float* matrix) override {
         if (!mDispatch.setLayerColorTransform) {
-            if (isIdentityMatrix(matrix)) {
-                // If an identity matrix is set, then we can remove the layer from client
-                // composition list.
-                mClientCompositionLayers[display].erase(layer);
-                return Error::UNSUPPORTED;
-            }
-            // if setLayerColorTransform is not implemented, per spec we want to make sure the
-            // layer marked as client composition, and thus we maintain a list, and mark all these
-            // layers as client composition later before validate the display.
-            mClientCompositionLayers[display].insert(layer);
             return Error::UNSUPPORTED;
         }
         int32_t err = mDispatch.setLayerColorTransform(mDevice, display, layer, matrix);
@@ -318,79 +294,7 @@
         return true;
     }
 
-    int32_t getChangedCompositionTypes(Display display, uint32_t* outTypesCount,
-                                       Layer* outChangedLayers,
-                                       IComposerClient::Composition* outCompositionTypes) override {
-        if (outChangedLayers == nullptr && outCompositionTypes == nullptr) {
-            uint32_t typesCount = 0;
-            int32_t error = BaseType2_1::getChangedCompositionTypesInternal(display, &typesCount,
-                                                                            nullptr, nullptr);
-            if (error != HWC2_ERROR_NONE) {
-                return error;
-            }
-            mChangedLayersCache[display].reserve(typesCount);
-            mCompositionTypesCache[display].reserve(typesCount);
-            error = BaseType2_1::getChangedCompositionTypesInternal(
-                    display, &typesCount, mChangedLayersCache[display].data(),
-                    mCompositionTypesCache[display].data());
-            if (error != HWC2_ERROR_NONE) {
-                return error;
-            }
-            for (Layer layer : mClientCompositionLayers[display]) {
-                bool exist = false;
-                for (uint32_t i = 0; i < typesCount; ++i) {
-                    if (mChangedLayersCache[display][i] == layer) {
-                        exist = true;
-                        break;
-                    }
-                }
-                if (!exist) {
-                    mChangedLayersCache[display].push_back(layer);
-                    mCompositionTypesCache[display].push_back(IComposerClient::Composition::CLIENT);
-                }
-            }
-            *outTypesCount = mChangedLayersCache[display].size();
-            return error;
-        }
-        for (uint32_t i = 0; i < *outTypesCount; ++i) {
-            if (outChangedLayers != nullptr) {
-                outChangedLayers[i] = mChangedLayersCache[display][i];
-            }
-            if (outCompositionTypes != nullptr) {
-                outCompositionTypes[i] = mCompositionTypesCache[display][i];
-            }
-        }
-        return HWC2_ERROR_NONE;
-    }
-
-    void onLayerDestroyed(Display display, Layer layer) override {
-        if (mClientCompositionLayers.find(display) == mClientCompositionLayers.end()) {
-            return;
-        }
-        mClientCompositionLayers[display].erase(layer);
-    }
-
-    void onBeforeValidateDisplay(Display display) override {
-        if (mClientCompositionLayers.find(display) == mClientCompositionLayers.end()) {
-            return;
-        }
-
-        // clear the cache proactively so that we don't hold too much memory over time.
-        mChangedLayersCache[display].clear();
-        mCompositionTypesCache[display].clear();
-
-        // SET_LAYER_COLOR_TRANSFORM is optional, and thus if it's not implemented, we need to
-        // follow the spec to make sure those layers marked as client composition before validate
-        // the display.
-        if (!mDispatch.setLayerColorTransform) {
-            for (Layer layer : mClientCompositionLayers[display]) {
-                BaseType2_1::setLayerCompositionType(
-                        display, layer, static_cast<int32_t>(IComposerClient::Composition::CLIENT));
-            }
-        }
-    }
-
-  private:
+   private:
     struct {
         HWC2_PFN_GET_DISPLAY_IDENTIFICATION_DATA getDisplayIdentificationData;
         HWC2_PFN_SET_LAYER_COLOR_TRANSFORM setLayerColorTransform;
@@ -414,9 +318,6 @@
     using BaseType2_2::getRenderIntents;
     using BaseType2_2::setColorMode_2_2;
     using BaseType2_2::setLayerPerFrameMetadata;
-    std::map<Display, std::set<Layer>> mClientCompositionLayers;
-    std::map<Display, std::vector<Layer>> mChangedLayersCache;
-    std::map<Display, std::vector<IComposerClient::Composition>> mCompositionTypesCache;
 };
 
 }  // namespace detail