ozone: Allow ozone evdev/kvm features to be enabled without running on ChromeOS.

base/sys_info_chromeos.cc

 // Copyright (c) 2012 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 "base/sys_info.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include "base/base_switches.h"
+#include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
@@ skipping 23 matching lines @@
 const char kLsbReleaseTimeKey[] = "LSB_RELEASE_TIME";  // Seconds since epoch
 
 const char kLsbReleaseSourceKey[] = "lsb-release";
 const char kLsbReleaseSourceEnv[] = "env";
 const char kLsbReleaseSourceFile[] = "file";
 
 class ChromeOSVersionInfo {
  public:
   ChromeOSVersionInfo() {
     Parse();
+
+    // Running as system compositor by default when running on ChromeOS.
+    is_running_as_system_compositor_ = is_running_on_chromeos_;
+
+    CommandLine* command_line = CommandLine::ForCurrentProcess();
+    if (command_line->HasSwitch(switches::kEnableSystemCompositorMode))
+      is_running_as_system_compositor_ = true;
+    if (command_line->HasSwitch(switches::kDisableSystemCompositorMode))
+      is_running_as_system_compositor_ = false;
   }
 
   void Parse() {
     lsb_release_map_.clear();
     major_version_ = 0;
     minor_version_ = 0;
     bugfix_version_ = 0;
     is_running_on_chromeos_ = false;
 
     std::string lsb_release, lsb_release_time_str;
@@ skipping 36 matching lines @@
     *major_version = major_version_;
     *minor_version = minor_version_;
     *bugfix_version = bugfix_version_;
   }
 
   const Time& lsb_release_time() const { return lsb_release_time_; }
   const SysInfo::LsbReleaseMap& lsb_release_map() const {
     return lsb_release_map_;
   }
   bool is_running_on_chromeos() const { return is_running_on_chromeos_; }
+  bool is_running_as_system_compositor() const {
+    return is_running_as_system_compositor_;
+  }
 
  private:
   void ParseLsbRelease(const std::string& lsb_release) {
     // Parse and cache lsb_release key pairs. There should only be a handful
     // of entries so the overhead for this will be small, and it can be
     // useful for debugging.
     base::StringPairs pairs;
     SplitStringIntoKeyValuePairs(lsb_release, '=', '\n', &pairs);
     for (size_t i = 0; i < pairs.size(); ++i) {
       std::string key, value;
@@ skipping 35 matching lines @@
       }
     }
   }
 
   Time lsb_release_time_;
   SysInfo::LsbReleaseMap lsb_release_map_;
   int32_t major_version_;
   int32_t minor_version_;
   int32_t bugfix_version_;
   bool is_running_on_chromeos_;
+  bool is_running_as_system_compositor_;
 };
 
 static LazyInstance<ChromeOSVersionInfo>::Leaky
     g_chrome_os_version_info = LAZY_INSTANCE_INITIALIZER;
 
 ChromeOSVersionInfo& GetChromeOSVersionInfo() {
   return g_chrome_os_version_info.Get();
 }
 
 }  // namespace
@@ skipping 48 matching lines @@
 // static
 void SysInfo::SetChromeOSVersionInfoForTest(const std::string& lsb_release,
                                             const Time& lsb_release_time) {
   std::unique_ptr<Environment> env(Environment::Create());
   env->SetVar(kLsbReleaseKey, lsb_release);
   env->SetVar(kLsbReleaseTimeKey,
               DoubleToString(lsb_release_time.ToDoubleT()));
   g_chrome_os_version_info.Get().Parse();
 }
 
+// static
+bool SysInfo::IsRunningAsSystemCompositor() {
+  return GetChromeOSVersionInfo().is_running_as_system_compositor();
+}
+
 }  // namespace base