diff --git a/sdm/libs/core/display_base.cpp b/sdm/libs/core/display_base.cpp
index e143639..3ff8012 100644
--- a/sdm/libs/core/display_base.cpp
+++ b/sdm/libs/core/display_base.cpp
@@ -49,6 +49,7 @@
 }
 
 DisplayError DisplayBase::Init() {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   hw_panel_info_ = HWPanelInfo();
   hw_intf_->GetHWPanelInfo(&hw_panel_info_);
@@ -118,6 +119,7 @@
 }
 
 DisplayError DisplayBase::Deinit() {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (rotator_intf_) {
     rotator_intf_->UnregisterDisplay(display_rotator_ctx_);
   }
@@ -196,7 +198,8 @@
 }
 
 DisplayError DisplayBase::Prepare(LayerStack *layer_stack) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
+  DisplayError error = kErrorNone;
 
   if (!active_) {
     return kErrorPermission;
@@ -206,19 +209,13 @@
     return kErrorParameters;
   }
 
-  return PrepareLocked(layer_stack);
-}
-
-DisplayError DisplayBase::PrepareLocked(LayerStack *layer_stack) {
-  DisplayError error = kErrorNone;
-
   error = ValidateGPUTarget(layer_stack);
   if (error != kErrorNone) {
     return error;
   }
 
   if (color_mgr_ && color_mgr_->NeedsPartialUpdateDisable()) {
-    DisablePartialUpdateOneFrameLocked();
+    DisablePartialUpdateOneFrame();
   }
 
   if (partial_update_control_ == false || disable_pu_one_frame_) {
@@ -270,7 +267,8 @@
 }
 
 DisplayError DisplayBase::Commit(LayerStack *layer_stack) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
+  DisplayError error = kErrorNone;
 
   if (!active_) {
     pending_commit_ = false;
@@ -288,12 +286,6 @@
 
   pending_commit_ = false;
 
-  return CommitLocked(layer_stack);
-}
-
-DisplayError DisplayBase::CommitLocked(LayerStack *layer_stack) {
-  DisplayError error = kErrorNone;
-
   // Layer stack attributes has changed, need to Reconfigure, currently in use for Hybrid Comp
   if (layer_stack->flags.attributes_changed) {
     error = comp_manager_->ReConfigure(display_comp_ctx_, &hw_layers_);
@@ -347,6 +339,7 @@
 }
 
 DisplayError DisplayBase::Flush() {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
 
   if (!active_) {
@@ -376,6 +369,7 @@
 }
 
 DisplayError DisplayBase::GetDisplayState(DisplayState *state) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!state) {
     return kErrorParameters;
   }
@@ -385,10 +379,12 @@
 }
 
 DisplayError DisplayBase::GetNumVariableInfoConfigs(uint32_t *count) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   return hw_intf_->GetNumDisplayAttributes(count);
 }
 
 DisplayError DisplayBase::GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   HWDisplayAttributes attrib;
   if (hw_intf_->GetDisplayAttributes(index, &attrib) == kErrorNone) {
     *variable_info = attrib;
@@ -399,10 +395,12 @@
 }
 
 DisplayError DisplayBase::GetActiveConfig(uint32_t *index) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   return hw_intf_->GetActiveConfig(index);
 }
 
 DisplayError DisplayBase::GetVSyncState(bool *enabled) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!enabled) {
     return kErrorParameters;
   }
@@ -412,11 +410,8 @@
   return kErrorNone;
 }
 
-bool DisplayBase::IsUnderscanSupported() {
-  return underscan_supported_;
-}
-
 DisplayError DisplayBase::SetDisplayState(DisplayState state) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   bool active = false;
 
@@ -479,11 +474,7 @@
 }
 
 DisplayError DisplayBase::SetActiveConfig(uint32_t index) {
-  SCOPE_LOCK(locker_);
-  return SetActiveConfigLocked(index);
-}
-
-DisplayError DisplayBase::SetActiveConfigLocked(uint32_t index) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   uint32_t active_index = 0;
 
@@ -501,12 +492,8 @@
   return ReconfigureDisplay();
 }
 
-DisplayError DisplayBase::SetActiveConfig(DisplayConfigVariableInfo *variable_info) {
-  SCOPE_LOCK(locker_);
-  return SetActiveConfigLocked(variable_info);
-}
-
 DisplayError DisplayBase::SetMaxMixerStages(uint32_t max_mixer_stages) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
 
   error = comp_manager_->SetMaxMixerStages(display_comp_ctx_, max_mixer_stages);
@@ -518,29 +505,8 @@
   return error;
 }
 
-DisplayError DisplayBase::ControlPartialUpdate(bool enable, uint32_t *pending) {
-  SCOPE_LOCK(locker_);
-  return ControlPartialUpdateLocked(enable, pending);
-}
-
-DisplayError DisplayBase::DisablePartialUpdateOneFrame() {
-  SCOPE_LOCK(locker_);
-  return DisablePartialUpdateOneFrameLocked();
-}
-
-DisplayError DisplayBase::SetDisplayMode(uint32_t mode) {
-  return kErrorNotSupported;
-}
-
-DisplayError DisplayBase::SetPanelBrightness(int level) {
-  return kErrorNotSupported;
-}
-
-DisplayError DisplayBase::OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level) {
-  return kErrorNotSupported;
-}
-
 void DisplayBase::AppendDump(char *buffer, uint32_t length) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   HWDisplayAttributes attrib;
   uint32_t active_index = 0;
   uint32_t num_modes = 0;
@@ -677,6 +643,7 @@
 }
 
 bool DisplayBase::IsRotationRequired(HWLayers *hw_layers) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   HWLayersInfo &layer_info = hw_layers->info;
 
   for (uint32_t i = 0; i < layer_info.count; i++) {
@@ -706,6 +673,7 @@
 DisplayError DisplayBase::ColorSVCRequestRoute(const PPDisplayAPIPayload &in_payload,
                                                PPDisplayAPIPayload *out_payload,
                                                PPPendingParams *pending_action) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (color_mgr_)
     return color_mgr_->ColorSVCRequestRoute(in_payload, out_payload, pending_action);
   else
@@ -713,6 +681,7 @@
 }
 
 DisplayError DisplayBase::GetColorModeCount(uint32_t *mode_count) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!mode_count) {
     return kErrorParameters;
   }
@@ -734,6 +703,7 @@
 
 DisplayError DisplayBase::GetColorModes(uint32_t *mode_count,
                                         std::vector<std::string> *color_modes) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!mode_count || !color_modes) {
     return kErrorParameters;
   }
@@ -767,6 +737,7 @@
 }
 
 DisplayError DisplayBase::SetColorMode(const std::string &color_mode) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!color_mgr_) {
     return kErrorNotSupported;
   }
@@ -794,6 +765,7 @@
 }
 
 DisplayError DisplayBase::SetColorTransform(const uint32_t length, const double *color_transform) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!color_mgr_) {
     return kErrorNotSupported;
   }
@@ -806,6 +778,7 @@
 }
 
 DisplayError DisplayBase::ApplyDefaultDisplayMode() {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (color_mgr_)
     return color_mgr_->ApplyDefaultDisplayMode();
   else
@@ -813,6 +786,7 @@
 }
 
 DisplayError DisplayBase::SetCursorPosition(int x, int y) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (state_ != kStateOn) {
     return kErrorNotSupported;
   }
@@ -827,6 +801,7 @@
 
 DisplayError DisplayBase::GetRefreshRateRange(uint32_t *min_refresh_rate,
                                               uint32_t *max_refresh_rate) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   // The min and max refresh rates will be same when the HWPanelInfo does not contain valid rates.
   // Usually for secondary displays, command mode panels
   HWDisplayAttributes display_attributes;
@@ -843,11 +818,8 @@
   return error;
 }
 
-DisplayError DisplayBase::GetPanelBrightness(int *level) {
-  return kErrorNotSupported;
-}
-
 DisplayError DisplayBase::SetVSyncState(bool enable) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   if (vsync_enable_ != enable) {
     error = hw_intf_->SetVSyncState(enable);
@@ -859,6 +831,7 @@
 }
 
 DisplayError DisplayBase::ReconfigureDisplay() {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   HWDisplayAttributes display_attributes;
   HWMixerAttributes mixer_attributes;
@@ -897,7 +870,7 @@
   }
 
   if (mixer_attributes != mixer_attributes_) {
-    DisablePartialUpdateOneFrameLocked();
+    DisablePartialUpdateOneFrame();
   }
 
   display_attributes_ = display_attributes;
@@ -908,20 +881,12 @@
 }
 
 DisplayError DisplayBase::SetMixerResolution(uint32_t width, uint32_t height) {
-  SCOPE_LOCK(locker_);
-  return SetMixerResolutionLocked(width, height);
-}
-
-DisplayError DisplayBase::SetMixerResolutionLocked(uint32_t width, uint32_t height) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   return ReconfigureMixer(width, height);
 }
 
 DisplayError DisplayBase::GetMixerResolution(uint32_t *width, uint32_t *height) {
-  SCOPE_LOCK(locker_);
-  return GetMixerResolutionLocked(width, height);
-}
-
-DisplayError DisplayBase::GetMixerResolutionLocked(uint32_t *width, uint32_t *height) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!width || !height) {
     return kErrorParameters;
   }
@@ -933,6 +898,7 @@
 }
 
 DisplayError DisplayBase::ReconfigureMixer(uint32_t width, uint32_t height) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
 
   HWMixerAttributes mixer_attributes;
@@ -949,6 +915,7 @@
 
 bool DisplayBase::NeedsMixerReconfiguration(LayerStack *layer_stack, uint32_t *new_mixer_width,
                                             uint32_t *new_mixer_height) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   uint32_t layer_count = UINT32(layer_stack->layers.size());
 
   uint32_t fb_width  = fb_config_.x_pixels;
@@ -1016,12 +983,7 @@
 }
 
 DisplayError DisplayBase::SetFrameBufferConfig(const DisplayConfigVariableInfo &variable_info) {
-  SCOPE_LOCK(locker_);
-  return SetFrameBufferConfigLocked(variable_info);
-}
-
-DisplayError DisplayBase::SetFrameBufferConfigLocked(
-                                   const DisplayConfigVariableInfo &variable_info) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   uint32_t width = variable_info.x_pixels;
   uint32_t height = variable_info.y_pixels;
 
@@ -1057,11 +1019,7 @@
 }
 
 DisplayError DisplayBase::GetFrameBufferConfig(DisplayConfigVariableInfo *variable_info) {
-  SCOPE_LOCK(locker_);
-  return GetFrameBufferConfigLocked(variable_info);
-}
-
-DisplayError DisplayBase::GetFrameBufferConfigLocked(DisplayConfigVariableInfo *variable_info) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!variable_info) {
     return kErrorParameters;
   }
@@ -1072,17 +1030,13 @@
 }
 
 DisplayError DisplayBase::SetDetailEnhancerData(const DisplayDetailEnhancerData &de_data) {
-  SCOPE_LOCK(locker_);
-  return SetDetailEnhancerDataLocked(de_data);
-}
-
-DisplayError DisplayBase::SetDetailEnhancerDataLocked(const DisplayDetailEnhancerData &de_data) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = comp_manager_->SetDetailEnhancerData(display_comp_ctx_, de_data);
   if (error != kErrorNone) {
     return error;
   }
 
-  DisablePartialUpdateOneFrameLocked();
+  DisablePartialUpdateOneFrame();
 
   return kErrorNone;
 }
diff --git a/sdm/libs/core/display_base.h b/sdm/libs/core/display_base.h
index b802ea6..058cdc4 100644
--- a/sdm/libs/core/display_base.h
+++ b/sdm/libs/core/display_base.h
@@ -29,9 +29,9 @@
 #include <private/strategy_interface.h>
 #include <private/rotator_interface.h>
 #include <private/color_interface.h>
-#include <utils/locker.h>
 
 #include <map>
+#include <mutex>
 #include <string>
 #include <vector>
 
@@ -42,10 +42,13 @@
 
 namespace sdm {
 
+using std::recursive_mutex;
+using std::lock_guard;
+
 class RotatorCtrl;
 class HWInfoInterface;
 
-class DisplayBase : public DisplayInterface {
+class DisplayBase : public DisplayInterface, DumpImpl {
  public:
   DisplayBase(DisplayType display_type, DisplayEventHandler *event_handler,
               HWDeviceType hw_device_type, BufferSyncHandler *buffer_sync_handler,
@@ -54,8 +57,8 @@
   virtual ~DisplayBase() { }
   virtual DisplayError Init();
   virtual DisplayError Deinit();
-  DisplayError Prepare(LayerStack *layer_stack) final;
-  DisplayError Commit(LayerStack *layer_stack) final;
+  DisplayError Prepare(LayerStack *layer_stack);
+  DisplayError Commit(LayerStack *layer_stack);
   virtual DisplayError Flush();
   virtual DisplayError GetDisplayState(DisplayState *state);
   virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count);
@@ -63,15 +66,29 @@
   virtual DisplayError GetActiveConfig(uint32_t *index);
   virtual DisplayError GetVSyncState(bool *enabled);
   virtual DisplayError SetDisplayState(DisplayState state);
-  DisplayError SetActiveConfig(uint32_t index) final;
-  DisplayError SetActiveConfig(DisplayConfigVariableInfo *variable_info) final;
+  virtual DisplayError SetActiveConfig(uint32_t index);
+  virtual DisplayError SetActiveConfig(DisplayConfigVariableInfo *variable_info) {
+    return kErrorNotSupported;
+  }
   virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
-  DisplayError ControlPartialUpdate(bool enable, uint32_t *pending) final;
-  DisplayError DisablePartialUpdateOneFrame() final;
-  virtual DisplayError SetDisplayMode(uint32_t mode);
-  virtual bool IsUnderscanSupported();
-  virtual DisplayError SetPanelBrightness(int level);
-  virtual DisplayError OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level);
+  virtual DisplayError ControlPartialUpdate(bool enable, uint32_t *pending) {
+    return kErrorNotSupported;
+  }
+  virtual DisplayError DisablePartialUpdateOneFrame() {
+    return kErrorNotSupported;
+  }
+  virtual DisplayError SetDisplayMode(uint32_t mode) {
+    return kErrorNotSupported;
+  }
+  virtual bool IsUnderscanSupported() {
+    return false;
+  }
+  virtual DisplayError SetPanelBrightness(int level) {
+    return kErrorNotSupported;
+  }
+  virtual DisplayError OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level) {
+    return kErrorNotSupported;
+  }
   virtual DisplayError ColorSVCRequestRoute(const PPDisplayAPIPayload &in_payload,
                                             PPDisplayAPIPayload *out_payload,
                                             PPPendingParams *pending_action);
@@ -82,33 +99,18 @@
   virtual DisplayError ApplyDefaultDisplayMode(void);
   virtual DisplayError SetCursorPosition(int x, int y);
   virtual DisplayError GetRefreshRateRange(uint32_t *min_refresh_rate, uint32_t *max_refresh_rate);
-  virtual DisplayError GetPanelBrightness(int *level);
+  virtual DisplayError GetPanelBrightness(int *level) {
+    return kErrorNotSupported;
+  }
   virtual DisplayError SetVSyncState(bool enable);
-  DisplayError SetMixerResolution(uint32_t width, uint32_t height) final;
-  DisplayError GetMixerResolution(uint32_t *width, uint32_t *height) final;
-  DisplayError SetFrameBufferConfig(const DisplayConfigVariableInfo &variable_info) final;
-  DisplayError GetFrameBufferConfig(DisplayConfigVariableInfo *variable_info) final;
-  DisplayError SetDetailEnhancerData(const DisplayDetailEnhancerData &de_data) final;
+  virtual void SetIdleTimeoutMs(uint32_t timeout_ms) {}
+  virtual DisplayError SetMixerResolution(uint32_t width, uint32_t height);
+  virtual DisplayError GetMixerResolution(uint32_t *width, uint32_t *height);
+  virtual DisplayError SetFrameBufferConfig(const DisplayConfigVariableInfo &variable_info);
+  virtual DisplayError GetFrameBufferConfig(DisplayConfigVariableInfo *variable_info);
+  virtual DisplayError SetDetailEnhancerData(const DisplayDetailEnhancerData &de_data);
 
  protected:
-  virtual DisplayError PrepareLocked(LayerStack *layer_stack);
-  virtual DisplayError CommitLocked(LayerStack *layer_stack);
-  virtual DisplayError SetActiveConfigLocked(uint32_t index);
-  virtual DisplayError SetActiveConfigLocked(DisplayConfigVariableInfo *variable_info) {
-    return kErrorNotSupported;
-  }
-  virtual DisplayError ControlPartialUpdateLocked(bool enable, uint32_t *pending) {
-    return kErrorNotSupported;
-  }
-  virtual DisplayError DisablePartialUpdateOneFrameLocked() {
-    return kErrorNotSupported;
-  }
-  virtual DisplayError SetMixerResolutionLocked(uint32_t width, uint32_t height);
-  virtual DisplayError GetMixerResolutionLocked(uint32_t *width, uint32_t *height);
-  virtual DisplayError SetFrameBufferConfigLocked(const DisplayConfigVariableInfo &variable_info);
-  virtual DisplayError GetFrameBufferConfigLocked(DisplayConfigVariableInfo *variable_info);
-  virtual DisplayError SetDetailEnhancerDataLocked(const DisplayDetailEnhancerData &de_data);
-
   // DumpImpl method
   void AppendDump(char *buffer, uint32_t length);
 
@@ -120,8 +122,7 @@
                                  uint32_t *new_mixer_height);
   DisplayError ReconfigureMixer(uint32_t width, uint32_t height);
 
-
-  Locker locker_;
+  recursive_mutex recursive_mutex_;
   DisplayType display_type_;
   DisplayEventHandler *event_handler_ = NULL;
   HWDeviceType hw_device_type_;
@@ -138,7 +139,6 @@
   HWLayers hw_layers_;
   bool pending_commit_ = false;
   bool vsync_enable_ = false;
-  bool underscan_supported_ = false;
   uint32_t max_mixer_stages_ = 0;
   HWInfoInterface *hw_info_intf_ = NULL;
   ColorManagerProxy *color_mgr_ = NULL;  // each display object owns its ColorManagerProxy
diff --git a/sdm/libs/core/display_hdmi.cpp b/sdm/libs/core/display_hdmi.cpp
index a53995b..536c91d 100644
--- a/sdm/libs/core/display_hdmi.cpp
+++ b/sdm/libs/core/display_hdmi.cpp
@@ -44,7 +44,7 @@
 }
 
 DisplayError DisplayHDMI::Init() {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   DisplayError error = HWHDMI::Create(&hw_intf_, hw_info_intf_,
                                       DisplayBase::buffer_sync_handler_);
@@ -98,7 +98,7 @@
 }
 
 DisplayError DisplayHDMI::Deinit() {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   DisplayError error = DisplayBase::Deinit();
   HWHDMI::Destroy(hw_intf_);
@@ -106,7 +106,8 @@
   return error;
 }
 
-DisplayError DisplayHDMI::PrepareLocked(LayerStack *layer_stack) {
+DisplayError DisplayHDMI::Prepare(LayerStack *layer_stack) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   uint32_t new_mixer_width = 0;
   uint32_t new_mixer_height = 0;
@@ -122,64 +123,12 @@
 
   SetS3DMode(layer_stack);
 
-  return DisplayBase::PrepareLocked(layer_stack);
-}
-
-DisplayError DisplayHDMI::Flush() {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::Flush();
-}
-
-DisplayError DisplayHDMI::GetDisplayState(DisplayState *state) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetDisplayState(state);
-}
-
-DisplayError DisplayHDMI::GetNumVariableInfoConfigs(uint32_t *count) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetNumVariableInfoConfigs(count);
-}
-
-DisplayError DisplayHDMI::GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetConfig(index, variable_info);
-}
-
-DisplayError DisplayHDMI::GetActiveConfig(uint32_t *index) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetActiveConfig(index);
-}
-
-DisplayError DisplayHDMI::GetVSyncState(bool *enabled) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetVSyncState(enabled);
-}
-
-DisplayError DisplayHDMI::SetDisplayState(DisplayState state) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetDisplayState(state);
-}
-
-DisplayError DisplayHDMI::SetVSyncState(bool enable) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetVSyncState(enable);
-}
-
-void DisplayHDMI::SetIdleTimeoutMs(uint32_t timeout_ms) { }
-
-DisplayError DisplayHDMI::SetMaxMixerStages(uint32_t max_mixer_stages) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetMaxMixerStages(max_mixer_stages);
-}
-
-DisplayError DisplayHDMI::SetDisplayMode(uint32_t mode) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetDisplayMode(mode);
+  return DisplayBase::Prepare(layer_stack);
 }
 
 DisplayError DisplayHDMI::GetRefreshRateRange(uint32_t *min_refresh_rate,
                                               uint32_t *max_refresh_rate) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
 
   if (hw_panel_info_.min_fps && hw_panel_info_.max_fps) {
@@ -193,7 +142,7 @@
 }
 
 DisplayError DisplayHDMI::SetRefreshRate(uint32_t refresh_rate) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   if (!active_) {
     return kErrorPermission;
@@ -208,17 +157,12 @@
 }
 
 bool DisplayHDMI::IsUnderscanSupported() {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::IsUnderscanSupported();
-}
-
-DisplayError DisplayHDMI::SetPanelBrightness(int level) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetPanelBrightness(level);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
+  return underscan_supported_;
 }
 
 DisplayError DisplayHDMI::OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   return hw_intf_->OnMinHdcpEncryptionLevelChange(min_enc_level);
 }
 
@@ -313,16 +257,6 @@
   }
 }
 
-void DisplayHDMI::AppendDump(char *buffer, uint32_t length) {
-  SCOPE_LOCK(locker_);
-  DisplayBase::AppendDump(buffer, length);
-}
-
-DisplayError DisplayHDMI::SetCursorPosition(int x, int y) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetCursorPosition(x, y);
-}
-
 void DisplayHDMI::SetS3DMode(LayerStack *layer_stack) {
   uint32_t s3d_layer_count = 0;
   HWS3DMode s3d_mode = kS3DModeNone;
diff --git a/sdm/libs/core/display_hdmi.h b/sdm/libs/core/display_hdmi.h
index b3ec9af..3a3c0dc 100644
--- a/sdm/libs/core/display_hdmi.h
+++ b/sdm/libs/core/display_hdmi.h
@@ -35,31 +35,18 @@
 
 class HWHDMIInterface;
 
-class DisplayHDMI : public DisplayBase, DumpImpl, HWEventHandler {
+class DisplayHDMI : public DisplayBase, HWEventHandler {
  public:
   DisplayHDMI(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
               BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
               RotatorInterface *rotator_intf);
   virtual DisplayError Init();
   virtual DisplayError Deinit();
-  virtual DisplayError Flush();
-  virtual DisplayError GetDisplayState(DisplayState *state);
-  virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count);
-  virtual DisplayError GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info);
-  virtual DisplayError GetActiveConfig(uint32_t *index);
-  virtual DisplayError GetVSyncState(bool *enabled);
-  virtual DisplayError SetDisplayState(DisplayState state);
-  virtual DisplayError SetVSyncState(bool enable);
-  virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
-  virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
-  virtual DisplayError SetDisplayMode(uint32_t mode);
+  virtual DisplayError Prepare(LayerStack *layer_stack);
   virtual DisplayError GetRefreshRateRange(uint32_t *min_refresh_rate, uint32_t *max_refresh_rate);
   virtual DisplayError SetRefreshRate(uint32_t refresh_rate);
   virtual bool IsUnderscanSupported();
-  virtual DisplayError SetPanelBrightness(int level);
   virtual DisplayError OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level);
-  virtual void AppendDump(char *buffer, uint32_t length);
-  virtual DisplayError SetCursorPosition(int x, int y);
 
   // Implement the HWEventHandlers
   virtual DisplayError VSync(int64_t timestamp);
@@ -69,11 +56,11 @@
   virtual void CECMessage(char *message);
 
  private:
-  virtual DisplayError PrepareLocked(LayerStack *layer_stack);
-  virtual uint32_t GetBestConfig(HWS3DMode s3d_mode);
-  virtual void GetScanSupport();
-  virtual void SetS3DMode(LayerStack *layer_stack);
+  uint32_t GetBestConfig(HWS3DMode s3d_mode);
+  void GetScanSupport();
+  void SetS3DMode(LayerStack *layer_stack);
 
+  bool underscan_supported_ = false;
   HWScanSupport scan_support_;
   std::map<LayerBufferS3DFormat, HWS3DMode> s3d_format_to_mode_;
   std::vector<const char *> event_list_ = {"vsync_event", "idle_notify", "cec/rd_msg",
diff --git a/sdm/libs/core/display_primary.cpp b/sdm/libs/core/display_primary.cpp
index 41e4c29..ad1d3d6 100644
--- a/sdm/libs/core/display_primary.cpp
+++ b/sdm/libs/core/display_primary.cpp
@@ -47,7 +47,7 @@
 }
 
 DisplayError DisplayPrimary::Init() {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   DisplayError error = HWPrimary::Create(&hw_intf_, hw_info_intf_,
                                          DisplayBase::buffer_sync_handler_);
@@ -83,7 +83,7 @@
 }
 
 DisplayError DisplayPrimary::Deinit() {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   DisplayError error = DisplayBase::Deinit();
   HWPrimary::Destroy(hw_intf_);
@@ -91,7 +91,8 @@
   return error;
 }
 
-DisplayError DisplayPrimary::PrepareLocked(LayerStack *layer_stack) {
+DisplayError DisplayPrimary::Prepare(LayerStack *layer_stack) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   uint32_t new_mixer_width = 0;
   uint32_t new_mixer_height = 0;
@@ -105,10 +106,11 @@
     }
   }
 
-  return DisplayBase::PrepareLocked(layer_stack);
+  return DisplayBase::Prepare(layer_stack);
 }
 
-DisplayError DisplayPrimary::CommitLocked(LayerStack *layer_stack) {
+DisplayError DisplayPrimary::Commit(LayerStack *layer_stack) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
 
   // Enabling auto refresh is async and needs to happen before commit ioctl
@@ -118,7 +120,7 @@
 
   bool set_idle_timeout = comp_manager_->CanSetIdleTimeout(display_comp_ctx_);
 
-  error = DisplayBase::CommitLocked(layer_stack);
+  error = DisplayBase::Commit(layer_stack);
   if (error != kErrorNone) {
     return error;
   }
@@ -136,43 +138,8 @@
   return error;
 }
 
-DisplayError DisplayPrimary::Flush() {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::Flush();
-}
-
-DisplayError DisplayPrimary::GetDisplayState(DisplayState *state) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetDisplayState(state);
-}
-
-DisplayError DisplayPrimary::GetNumVariableInfoConfigs(uint32_t *count) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetNumVariableInfoConfigs(count);
-}
-
-DisplayError DisplayPrimary::GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetConfig(index, variable_info);
-}
-
-DisplayError DisplayPrimary::GetActiveConfig(uint32_t *index) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetActiveConfig(index);
-}
-
-DisplayError DisplayPrimary::GetVSyncState(bool *enabled) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetVSyncState(enabled);
-}
-
-bool DisplayPrimary::IsUnderscanSupported() {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::IsUnderscanSupported();
-}
-
 DisplayError DisplayPrimary::SetDisplayState(DisplayState state) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   error = DisplayBase::SetDisplayState(state);
   if (error != kErrorNone) {
@@ -187,13 +154,8 @@
   return kErrorNone;
 }
 
-DisplayError DisplayPrimary::SetVSyncState(bool enable) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetVSyncState(enable);
-}
-
 void DisplayPrimary::SetIdleTimeoutMs(uint32_t timeout_ms) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   // Idle fallback feature is supported only for video mode panel.
   if (hw_panel_info_.mode == kModeVideo) {
@@ -202,13 +164,8 @@
   idle_timeout_ms_ = timeout_ms;
 }
 
-DisplayError DisplayPrimary::SetMaxMixerStages(uint32_t max_mixer_stages) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetMaxMixerStages(max_mixer_stages);
-}
-
 DisplayError DisplayPrimary::SetDisplayMode(uint32_t mode) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   HWDisplayMode hw_display_mode = static_cast<HWDisplayMode>(mode);
   uint32_t pending = 0;
@@ -237,10 +194,10 @@
   }
 
   if (mode == kModeVideo) {
-    ControlPartialUpdateLocked(false /* enable */, &pending);
+    ControlPartialUpdate(false /* enable */, &pending);
     hw_intf_->SetIdleTimeoutMs(idle_timeout_ms_);
   } else if (mode == kModeCommand) {
-    ControlPartialUpdateLocked(true /* enable */, &pending);
+    ControlPartialUpdate(true /* enable */, &pending);
     hw_intf_->SetIdleTimeoutMs(0);
   }
 
@@ -248,13 +205,13 @@
 }
 
 DisplayError DisplayPrimary::SetPanelBrightness(int level) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   return hw_intf_->SetPanelBrightness(level);
 }
 
 DisplayError DisplayPrimary::GetRefreshRateRange(uint32_t *min_refresh_rate,
                                                  uint32_t *max_refresh_rate) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
 
   if (hw_panel_info_.min_fps && hw_panel_info_.max_fps) {
@@ -268,7 +225,7 @@
 }
 
 DisplayError DisplayPrimary::SetRefreshRate(uint32_t refresh_rate) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   if (!active_ || !hw_panel_info_.dynamic_fps) {
     return kErrorNotSupported;
@@ -287,11 +244,6 @@
   return DisplayBase::ReconfigureDisplay();
 }
 
-void DisplayPrimary::AppendDump(char *buffer, uint32_t length) {
-  SCOPE_LOCK(locker_);
-  DisplayBase::AppendDump(buffer, length);
-}
-
 DisplayError DisplayPrimary::VSync(int64_t timestamp) {
   if (vsync_enable_) {
     DisplayEventVSync vsync;
@@ -302,32 +254,23 @@
   return kErrorNone;
 }
 
-DisplayError DisplayPrimary::SetCursorPosition(int x, int y) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetCursorPosition(x, y);
-}
-
-DisplayError DisplayPrimary::Blank(bool blank) {
-  SCOPE_LOCK(locker_);
-  return kErrorNone;
-}
-
 void DisplayPrimary::IdleTimeout() {
   event_handler_->Refresh();
   comp_manager_->ProcessIdleTimeout(display_comp_ctx_);
 }
 
 void DisplayPrimary::ThermalEvent(int64_t thermal_level) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   comp_manager_->ProcessThermalEvent(display_comp_ctx_, thermal_level);
 }
 
 DisplayError DisplayPrimary::GetPanelBrightness(int *level) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   return hw_intf_->GetPanelBrightness(level);
 }
 
-DisplayError DisplayPrimary::ControlPartialUpdateLocked(bool enable, uint32_t *pending) {
+DisplayError DisplayPrimary::ControlPartialUpdate(bool enable, uint32_t *pending) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!pending) {
     return kErrorParameters;
   }
@@ -355,7 +298,8 @@
   return kErrorNone;
 }
 
-DisplayError DisplayPrimary::DisablePartialUpdateOneFrameLocked() {
+DisplayError DisplayPrimary::DisablePartialUpdateOneFrame() {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   disable_pu_one_frame_ = true;
 
   return kErrorNone;
diff --git a/sdm/libs/core/display_primary.h b/sdm/libs/core/display_primary.h
index 92e6c88..962f00c 100644
--- a/sdm/libs/core/display_primary.h
+++ b/sdm/libs/core/display_primary.h
@@ -34,45 +34,33 @@
 
 class HWPrimaryInterface;
 
-class DisplayPrimary : public DisplayBase, DumpImpl, HWEventHandler {
+class DisplayPrimary : public DisplayBase, HWEventHandler {
  public:
   DisplayPrimary(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
                  BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
                  RotatorInterface *rotator_intf);
   virtual DisplayError Init();
   virtual DisplayError Deinit();
-  virtual DisplayError Flush();
-  virtual DisplayError GetDisplayState(DisplayState *state);
-  virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count);
-  virtual DisplayError GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info);
-  virtual DisplayError GetActiveConfig(uint32_t *index);
-  virtual DisplayError GetVSyncState(bool *enabled);
+  virtual DisplayError Prepare(LayerStack *layer_stack);
+  virtual DisplayError Commit(LayerStack *layer_stack);
+  virtual DisplayError ControlPartialUpdate(bool enable, uint32_t *pending);
+  virtual DisplayError DisablePartialUpdateOneFrame();
   virtual DisplayError SetDisplayState(DisplayState state);
-  virtual DisplayError SetVSyncState(bool enable);
   virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
-  virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
   virtual DisplayError SetDisplayMode(uint32_t mode);
   virtual DisplayError GetRefreshRateRange(uint32_t *min_refresh_rate, uint32_t *max_refresh_rate);
   virtual DisplayError SetRefreshRate(uint32_t refresh_rate);
-  virtual bool IsUnderscanSupported();
   virtual DisplayError SetPanelBrightness(int level);
-  virtual void AppendDump(char *buffer, uint32_t length);
-  virtual DisplayError SetCursorPosition(int x, int y);
   virtual DisplayError GetPanelBrightness(int *level);
 
   // Implement the HWEventHandlers
   virtual DisplayError VSync(int64_t timestamp);
-  virtual DisplayError Blank(bool blank);
+  virtual DisplayError Blank(bool blank) { return kErrorNone; }
   virtual void IdleTimeout();
   virtual void ThermalEvent(int64_t thermal_level);
   virtual void CECMessage(char *message) { }
 
  private:
-  virtual DisplayError PrepareLocked(LayerStack *layer_stack);
-  virtual DisplayError CommitLocked(LayerStack *layer_stack);
-  virtual DisplayError ControlPartialUpdateLocked(bool enable, uint32_t *pending);
-  virtual DisplayError DisablePartialUpdateOneFrameLocked();
-
   uint32_t idle_timeout_ms_ = 0;
   std::vector<const char *> event_list_ = {"vsync_event", "show_blank_event", "idle_notify",
                                            "msm_fb_thermal_level", "thread_exit"};
diff --git a/sdm/libs/core/display_virtual.cpp b/sdm/libs/core/display_virtual.cpp
index a2e5009..f835ea4 100644
--- a/sdm/libs/core/display_virtual.cpp
+++ b/sdm/libs/core/display_virtual.cpp
@@ -42,7 +42,7 @@
 }
 
 DisplayError DisplayVirtual::Init() {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   DisplayError error = HWVirtual::Create(&hw_intf_, hw_info_intf_,
                                          DisplayBase::buffer_sync_handler_);
@@ -61,7 +61,7 @@
 }
 
 DisplayError DisplayVirtual::Deinit() {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   DisplayError error = DisplayBase::Deinit();
   HWVirtual::Destroy(hw_intf_);
@@ -69,56 +69,32 @@
   return error;
 }
 
-DisplayError DisplayVirtual::Flush() {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::Flush();
-}
-
-DisplayError DisplayVirtual::GetDisplayState(DisplayState *state) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetDisplayState(state);
-}
-
 DisplayError DisplayVirtual::GetNumVariableInfoConfigs(uint32_t *count) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   *count = 1;
   return kErrorNone;
 }
 
 DisplayError DisplayVirtual::GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   *variable_info = display_attributes_;
   return kErrorNone;
 }
 
 DisplayError DisplayVirtual::GetActiveConfig(uint32_t *index) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   *index = 0;
   return kErrorNone;
 }
 
-DisplayError DisplayVirtual::GetVSyncState(bool *enabled) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetVSyncState(enabled);
-}
-
-bool DisplayVirtual::IsUnderscanSupported() {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::IsUnderscanSupported();
-}
-
-DisplayError DisplayVirtual::SetDisplayState(DisplayState state) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetDisplayState(state);
-}
-
-DisplayError DisplayVirtual::SetActiveConfigLocked(DisplayConfigVariableInfo *variable_info) {
-  DisplayError error = kErrorNone;
+DisplayError DisplayVirtual::SetActiveConfig(DisplayConfigVariableInfo *variable_info) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   if (!variable_info) {
     return kErrorParameters;
   }
 
+  DisplayError error = kErrorNone;
   HWDisplayAttributes display_attributes;
   HWMixerAttributes mixer_attributes;
   DisplayConfigVariableInfo fb_config = *variable_info;
@@ -164,48 +140,5 @@
   return kErrorNone;
 }
 
-DisplayError DisplayVirtual::SetVSyncState(bool enable) {
-  SCOPE_LOCK(locker_);
-  return kErrorNotSupported;
-}
-
-void DisplayVirtual::SetIdleTimeoutMs(uint32_t timeout_ms) { }
-
-DisplayError DisplayVirtual::SetMaxMixerStages(uint32_t max_mixer_stages) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetMaxMixerStages(max_mixer_stages);
-}
-
-DisplayError DisplayVirtual::SetDisplayMode(uint32_t mode) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetDisplayMode(mode);
-}
-
-DisplayError DisplayVirtual::GetRefreshRateRange(uint32_t *min_refresh_rate,
-                                                 uint32_t *max_refresh_rate) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetRefreshRateRange(min_refresh_rate, max_refresh_rate);
-}
-
-DisplayError DisplayVirtual::SetRefreshRate(uint32_t refresh_rate) {
-  SCOPE_LOCK(locker_);
-  return kErrorNotSupported;
-}
-
-DisplayError DisplayVirtual::SetPanelBrightness(int level) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetPanelBrightness(level);
-}
-
-void DisplayVirtual::AppendDump(char *buffer, uint32_t length) {
-  SCOPE_LOCK(locker_);
-  DisplayBase::AppendDump(buffer, length);
-}
-
-DisplayError DisplayVirtual::SetCursorPosition(int x, int y) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetCursorPosition(x, y);
-}
-
 }  // namespace sdm
 
diff --git a/sdm/libs/core/display_virtual.h b/sdm/libs/core/display_virtual.h
index 59334a7..69af7f0 100644
--- a/sdm/libs/core/display_virtual.h
+++ b/sdm/libs/core/display_virtual.h
@@ -33,43 +33,33 @@
 
 class HWVirtualInterface;
 
-class DisplayVirtual : public DisplayBase, DumpImpl {
+class DisplayVirtual : public DisplayBase {
  public:
   DisplayVirtual(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
                  BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
                  RotatorInterface *rotator_intf);
   virtual DisplayError Init();
   virtual DisplayError Deinit();
-  virtual DisplayError Flush();
-  virtual DisplayError GetDisplayState(DisplayState *state);
   virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count);
   virtual DisplayError GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info);
   virtual DisplayError GetActiveConfig(uint32_t *index);
-  virtual DisplayError GetVSyncState(bool *enabled);
-  virtual DisplayError SetDisplayState(DisplayState state);
-  virtual DisplayError SetVSyncState(bool enable);
-  virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
-  virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
-  virtual DisplayError SetDisplayMode(uint32_t mode);
-  virtual DisplayError GetRefreshRateRange(uint32_t *min_refresh_rate, uint32_t *max_refresh_rate);
-  virtual DisplayError SetRefreshRate(uint32_t refresh_rate);
-  virtual bool IsUnderscanSupported();
-  virtual DisplayError SetPanelBrightness(int level);
-  virtual void AppendDump(char *buffer, uint32_t length);
-  virtual DisplayError SetCursorPosition(int x, int y);
-
- private:
-  virtual DisplayError SetActiveConfigLocked(uint32_t index) {
+  virtual DisplayError SetActiveConfig(uint32_t index) {
     return kErrorNotSupported;
   }
-  virtual DisplayError SetActiveConfigLocked(DisplayConfigVariableInfo *variable_info);
-  virtual DisplayError SetMixerResolutionLocked(uint32_t width, uint32_t height) {
+  virtual DisplayError SetActiveConfig(DisplayConfigVariableInfo *variable_info);
+  virtual DisplayError SetMixerResolution(uint32_t width, uint32_t height) {
     return kErrorNotSupported;
   }
-  virtual DisplayError GetMixerResolutionLocked(uint32_t *width, uint32_t *height) {
+  virtual DisplayError SetVSyncState(bool enable) {
     return kErrorNotSupported;
   }
-  virtual DisplayError SetDetailEnhancerDataLocked(const DisplayDetailEnhancerData &de_data) {
+  virtual DisplayError SetRefreshRate(uint32_t refresh_rate) {
+    return kErrorNotSupported;
+  }
+  virtual DisplayError GetMixerResolution(uint32_t *width, uint32_t *height) {
+    return kErrorNotSupported;
+  }
+  virtual DisplayError SetDetailEnhancerData(const DisplayDetailEnhancerData &de_data) {
     return kErrorNotSupported;
   }
 };