SystemDisplayApi: Introdice OverscanTracker

extensions/browser/api/system_display/system_display_api.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "extensions/browser/api/system_display/system_display_api.h"
 
+#include <map>
 #include <memory>
+#include <set>
 #include <string>
 
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "build/build_config.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_observer.h"
 #include "extensions/browser/api/system_display/display_info_provider.h"
 #include "extensions/common/api/system_display.h"
 
 #if defined(OS_CHROMEOS)
 #include "extensions/common/manifest_handlers/kiosk_mode_info.h"
 #endif
 
 namespace extensions {
 
 namespace display = api::system_display;
 
 const char SystemDisplayFunction::kCrosOnlyError[] =
     "Function available only on ChromeOS.";
 const char SystemDisplayFunction::kKioskOnlyError[] =
     "Only kiosk enabled extensions are allowed to use this function.";
 
+namespace {
+
+class OverscanTracker;
+
+static OverscanTracker* s_overscan_tracker = nullptr;
+
+// Singleton class to track overscan calibration overlays. An observer is
+// created per WebContents which tracks any calbiration overlays by id.
+// If the render frame is deleted (e.g. the tab is closed) before the overlay
+// calibraiton is completed, the observer will call the overscan complete
+// method to remove the overlay. When all observers are removed, the singleton
+// tracker will delete itself.
+class OverscanTracker {
+ public:
+  static OverscanTracker* Get();
+  static void AddDisplay(content::WebContents* web_contents,
+                         const std::string& id);
+  static void RemoveDisplay(content::WebContents* web_contents,
+                            const std::string& id);
+  static void RemoveObserver(content::WebContents* web_contents);
+
+  OverscanTracker() {}
+  ~OverscanTracker() {}
+
+ private:
+  class OverscanWebObserver;
+
+  OverscanWebObserver* GetObserver(content::WebContents* web_contents,
+                                   bool create);
+  bool RemoveObserverImpl(content::WebContents* web_contents);
+
+  using ObserverMap =
+      std::map<content::WebContents*, std::unique_ptr<OverscanWebObserver>>;
+  ObserverMap observers_;
+
+  DISALLOW_COPY_AND_ASSIGN(OverscanTracker);
+};
+
+class OverscanTracker::OverscanWebObserver
+    : public content::WebContentsObserver {
+ public:
+  explicit OverscanWebObserver(content::WebContents* web_contents)
+      : content::WebContentsObserver(web_contents) {}
+  ~OverscanWebObserver() override {}
+
+  // WebContentsObserver
+  void RenderFrameDeleted(
+      content::RenderFrameHost* render_frame_host) override {
+    for (const std::string& id : display_ids_) {
+      // Reset any uncomitted calibraiton changes and complete calibration to
+      // hide the overlay.
+      DisplayInfoProvider::Get()->OverscanCalibrationReset(id);
+      DisplayInfoProvider::Get()->OverscanCalibrationComplete(id);
+    }
+    OverscanTracker::RemoveObserver(web_contents());  // Deletes this.
+  }
+
+  void AddDisplay(const std::string& id) { display_ids_.insert(id); }
+
+  void RemoveDisplay(const std::string& id) {
+    display_ids_.erase(id);
+    if (display_ids_.empty())
+      OverscanTracker::RemoveObserver(web_contents());  // Deletes this.
+  }
+
+ private:
+  std::set<std::string> display_ids_;
+
+  DISALLOW_COPY_AND_ASSIGN(OverscanWebObserver);
+};
+
+// static
+OverscanTracker* OverscanTracker::Get() {
+  if (!s_overscan_tracker)
+    s_overscan_tracker = new OverscanTracker;
+  return s_overscan_tracker;
+}
+
+// static
+void OverscanTracker::AddDisplay(content::WebContents* web_contents,
+                                 const std::string& id) {
+  OverscanTracker::Get()->GetObserver(web_contents, true)->AddDisplay(id);
+}
+
+// static
+void OverscanTracker::RemoveDisplay(content::WebContents* web_contents,
+                                    const std::string& id) {
+  OverscanTracker* tracker = OverscanTracker::Get();
+  if (!tracker)

[xiyuan, 2016/12/07 21:32:40]

Should we use |s_overscan_tracker| directly since we might not want to create
the tracker in this method?

[stevenjb, 2016/12/07 21:54:42]

Oops, yes, thanks for catching! I don't actually need Get() so removing
entirely. Fixed.

+    return;
+  OverscanWebObserver* observer = tracker->GetObserver(web_contents, false);
+  if (observer)
+    observer->RemoveDisplay(id);
+}
+
+// static
+void OverscanTracker::RemoveObserver(content::WebContents* web_contents) {
+  if (OverscanTracker::Get()->RemoveObserverImpl(web_contents)) {
+    delete s_overscan_tracker;
+    s_overscan_tracker = nullptr;
+  }
+}
+
+OverscanTracker::OverscanWebObserver* OverscanTracker::GetObserver(
+    content::WebContents* web_contents,
+    bool create) {
+  ObserverMap::iterator iter = observers_.find(web_contents);
+  if (iter != observers_.end())
+    return iter->second.get();
+  if (!create)
+    return nullptr;
+  auto owned_observer = base::MakeUnique<OverscanWebObserver>(web_contents);
+  auto observer_ptr = owned_observer.get();
+  observers_[web_contents] = std::move(owned_observer);
+  return observer_ptr;
+}
+
+bool OverscanTracker::RemoveObserverImpl(content::WebContents* web_contents) {
+  observers_.erase(web_contents);
+  return observers_.empty();
+}
+
+}  // namespace
+
 bool SystemDisplayFunction::PreRunValidation(std::string* error) {
   if (!UIThreadExtensionFunction::PreRunValidation(error))
     return false;
 
 #if !defined(OS_CHROMEOS)
   *error = kCrosOnlyError;
   return false;
 #else
   if (!ShouldRestrictToKioskAndWebUI())
     return true;
@@ skipping 56 matching lines @@
   DisplayInfoProvider::Get()->EnableUnifiedDesktop(params->enabled);
   return RespondNow(NoArguments());
 }
 
 ExtensionFunction::ResponseAction
 SystemDisplayOverscanCalibrationStartFunction::Run() {
   std::unique_ptr<display::OverscanCalibrationStart::Params> params(
       display::OverscanCalibrationStart::Params::Create(*args_));
   if (!DisplayInfoProvider::Get()->OverscanCalibrationStart(params->id))
     return RespondNow(Error("Invalid display ID: " + params->id));
+  OverscanTracker::AddDisplay(GetSenderWebContents(), params->id);
   return RespondNow(NoArguments());
 }
 
 ExtensionFunction::ResponseAction
 SystemDisplayOverscanCalibrationAdjustFunction::Run() {
   std::unique_ptr<display::OverscanCalibrationAdjust::Params> params(
       display::OverscanCalibrationAdjust::Params::Create(*args_));
   if (!params)
     return RespondNow(Error("Invalid parameters"));
   if (!DisplayInfoProvider::Get()->OverscanCalibrationAdjust(params->id,
@@ skipping 15 matching lines @@
 }
 
 ExtensionFunction::ResponseAction
 SystemDisplayOverscanCalibrationCompleteFunction::Run() {
   std::unique_ptr<display::OverscanCalibrationComplete::Params> params(
       display::OverscanCalibrationComplete::Params::Create(*args_));
   if (!DisplayInfoProvider::Get()->OverscanCalibrationComplete(params->id)) {
     return RespondNow(
         Error("Calibration not started for display ID: " + params->id));
   }
+  OverscanTracker::RemoveDisplay(GetSenderWebContents(), params->id);
   return RespondNow(NoArguments());
 }
 
 ExtensionFunction::ResponseAction
 SystemDisplayTouchCalibrationStartFunction::Run() {
   std::unique_ptr<display::TouchCalibrationStart::Params> params(
       display::TouchCalibrationStart::Params::Create(*args_));
   if (!DisplayInfoProvider::Get()->IsTouchCalibrationActive(params->id)) {
     return RespondNow(Error(
         "Another touch calibration is already active."));
@@ skipping 26 matching lines @@
   if (!DisplayInfoProvider::Get()->IsTouchCalibrationActive(params->id)) {
     return RespondNow(Error(
         "Another touch calibration is already active."));
   }
   if (!DisplayInfoProvider::Get()->TouchCalibrationReset(params->id))
     return RespondNow(Error("Invalid display ID: " + params->id));
   return RespondNow(NoArguments());
 }
 
 }  // namespace extensions