Quirks Client for downloading and providing display profiles

ash/display/display_color_manager_chromeos.cc

 // Copyright 2015 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 "ash/display/display_color_manager_chromeos.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chromeos/chromeos_paths.h"
+#include "components/quirks_client/quirks_client.h"
 #include "third_party/qcms/src/qcms.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/display/types/gamma_ramp_rgb_entry.h"
 #include "ui/display/types/native_display_delegate.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 
 namespace ash {
 
 namespace {
 
-bool ParseFile(const base::FilePath& path,
-               DisplayColorManager::ColorCalibrationData* data) {
+class FakeDisplaySnapshot : public ui::DisplaySnapshot {
+ public:
+  FakeDisplaySnapshot(int64_t product_id)
+      : ui::DisplaySnapshot(0, gfx::Point(0, 0), gfx::Size(0, 0),
+                            ui::DISPLAY_CONNECTION_TYPE_NONE, false, false,
+                            "test", base::FilePath(),
+                            std::vector<const ui::DisplayMode*>(),
+                            nullptr, nullptr) {
+    product_id_ = product_id;
+  }
+  ~FakeDisplaySnapshot() override{};
+
+  // DisplaySnapshot override:
+  std::string ToString() const override { return display_name_; }
+
+  DISALLOW_COPY_AND_ASSIGN(FakeDisplaySnapshot);
+};
+
+bool ParseDisplayProfile(const int64_t display_id,
+                         const int64_t product_id,
+                         DisplayColorManager::ColorCalibrationData* data) {
+  quirks_client::QuirksClient::DownloadFinishedCallback* callback = nullptr;
+  // TODO(glevin): Do we want to add a callback so that we can apply the icc
+  // profile as soon as it's downloaded?
+  base::FilePath path =
+      quirks_client::QuirksClient::RequestIccProfilePath(product_id, callback);
+  std::string product_string = base::StringPrintf("0x%08" PRIx64, product_id);
+  if (path.empty()) {
+    VLOG(1) << "No icc file found with product id: " << product_string
+            << " for display id: " << display_id;
+  } else {
+    VLOG(1) << "Loading ICC file " << path.value()
+            << " for display id: " << display_id
+            << " with product id: " << product_string;
+  }
+
   if (!base::PathExists(path))  // No icc file for this display; not an error.
     return false;
   qcms_profile* display_profile = qcms_profile_from_path(path.value().c_str());
 
   if (!display_profile) {
     LOG(WARNING) << "Unable to load ICC file: " << path.value();
     return false;
   }
 
   size_t vcgt_channel_length =
@@ skipping 12 matching lines @@
     return false;
   }
 
   data->lut.resize(vcgt_channel_length);
   for (size_t i = 0; i < vcgt_channel_length; ++i) {
     data->lut[i].r = vcgt_data[i];
     data->lut[i].g = vcgt_data[vcgt_channel_length + i];
     data->lut[i].b = vcgt_data[(vcgt_channel_length * 2) + i];
   }
   qcms_profile_release(display_profile);
+  VLOG(1) << "Gamma data successfully read from icc file";
   return true;
 }
 
-base::FilePath PathForDisplaySnapshot(const ui::DisplaySnapshot* snapshot) {
-  base::FilePath path;
-  CHECK(
-      PathService::Get(chromeos::DIR_DEVICE_COLOR_CALIBRATION_PROFILES, &path));
-  path = path.Append(
-      base::StringPrintf("%08" PRIx64 ".icc", snapshot->product_id()));
-  return path;
-}
-
 }  // namespace
 
 DisplayColorManager::DisplayColorManager(
     ui::DisplayConfigurator* configurator,
     base::SequencedWorkerPool* blocking_pool)
     : configurator_(configurator), blocking_pool_(blocking_pool) {
   configurator_->AddObserver(this);
 }
 
 DisplayColorManager::~DisplayColorManager() {
@@ skipping 22 matching lines @@
   }
 }
 
 void DisplayColorManager::LoadCalibrationForDisplay(
     const ui::DisplaySnapshot* display) {
   if (display->display_id() == gfx::Display::kInvalidDisplayID) {
     LOG(WARNING) << "Trying to load calibration data for invalid display id";
     return;
   }
 
-  base::FilePath path = PathForDisplaySnapshot(display);
-  VLOG(1) << "Loading ICC file " << path.value()
-          << " for display id: " << display->display_id()
-          << " with product id: " << display->product_id();
-
   scoped_ptr<ColorCalibrationData> data(new ColorCalibrationData());
   base::Callback<bool(void)> request(
-      base::Bind(&ParseFile, path, base::Unretained(data.get())));
+      base::Bind(&ParseDisplayProfile, display->display_id(),
+                 display->product_id(), base::Unretained(data.get())));
   base::PostTaskAndReplyWithResult(
       blocking_pool_, FROM_HERE, request,

[stevenjb, 2016/01/12 19:48:34]

I don't understand how this was ever correct. This is calling |request| on
|blocking_pool|, so:

ParseDisplayProfile -> quirks_client::QuirksClient::RequestIccProfilePath ->
g_delegate->Validate()

Shell::blocking_pool_ != base::MessageLoopForUI, so
base::MessageLoopForUI::IsCurrent() will return false.

       base::Bind(&DisplayColorManager::UpdateCalibrationData, AsWeakPtr(),
                  display->display_id(), display->product_id(),
                  base::Passed(std::move(data))));
 }
 
+// TODO!!! Remove!
+// Temporary debugging function for ChromeOS on Linux.  Provides an entry point
+// into ParseDisplayProfile() from the same thread / earlier up the stack from
+// it's actual calling location (which isn't hit due to lack of display device)
+void DisplayColorManager::LoadCalibrationForDisplayQuirksTest() {
+  FakeDisplaySnapshot fake_snapshot(0x06af5c10);
+  LoadCalibrationForDisplay(&fake_snapshot);
+}
+
 void DisplayColorManager::UpdateCalibrationData(
     int64_t display_id,
     int64_t product_id,
     scoped_ptr<ColorCalibrationData> data,
     bool success) {
   DCHECK_EQ(base::MessageLoop::current()->type(), base::MessageLoop::TYPE_UI);
   if (success) {
     // The map takes over ownership of the underlying memory.
     calibration_map_[product_id] = data.release();
     ApplyDisplayColorCalibration(display_id, product_id);
   }
 }
 
 DisplayColorManager::ColorCalibrationData::ColorCalibrationData() {}
 
 DisplayColorManager::ColorCalibrationData::~ColorCalibrationData() {}
 
 }  // namespace ash