Adds ash::MaterialDesignController

ash/material_design/material_design_controller.h

+// Copyright 2015 The Chromium Authors. All rights reserved.

[oshima, 2016/04/25 23:01:43]

2016

same for other files.

[varkha, 2016/04/25 23:16:05]

Done.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ASH_MATERIAL_DESIGN_MATERIAL_DESIGN_CONTROLLER_H_
+#define ASH_MATERIAL_DESIGN_MATERIAL_DESIGN_CONTROLLER_H_
+
+#include "ash/ash_export.h"
+#include "base/macros.h"
+
+namespace ash {
+
+namespace test {
+class MaterialDesignControllerTestAPI;
+}  // namespace test
+
+// Central controller to handle material design modes.
+class ASH_EXPORT MaterialDesignController {
+ public:
+  // Initializes |mode_|. Must be called before calling IsModeMaterial().
+  static void Initialize();
+
+  // Returns true if Material Design is enabled in Chrome OS system UI.
+  static bool IsMaterial();
+
+ private:
+  friend class test::MaterialDesignControllerTestAPI;
+
+  // Tracks whether |mode_| has been initialized. This is necessary so tests can
+  // reset the state back to a clean state during tear down.
+  static bool is_mode_initialized_;
+
+  // True if Material Design is enabled in Chrome OS system UI.
+  static bool mode_;

[oshima, 2016/04/25 23:01:43]

move private static to anonymous namespace in .cc

https://www.chromium.org/developers/coding-style/cpp-dos-and-donts

[varkha, 2016/04/25 23:16:05]

It is used by a friend MaterialDesignControllerTestAPI class.

[oshima, 2016/04/26 05:56:37]

In that case, how about defiing enum

enum class Mode {
  NONE,  // or UNINITIALIZED
  MATERIAL,
  CLASSIC
}

Then all you need is SetMode and DefualtMode
  

[varkha, 2016/04/26 15:06:02]

I think this doesn't do what I want to accomplish:
- explicit mandatory initialization (no legal default value)
- the only external interface is IsMaterial()
Basically I wanted the client code to only ever worry about true or false and
hide the rest in md_controller. Of course it is still possible with a tri-state
enum but looks more artificial to me and the header would still have that enum.

[oshima, 2016/04/26 16:06:57]

mode_(NONE) will do it.
This will stay the same. My key point is that a state machine like system is
better than multiple booleans. It's easier to understand and less error prone.
Here is an example:

public:

bool IsMaterial() {
  CHECK_NE(mode_, NONE);
  return mode_ == MATERIAL;
}

private:

enum class Mode {
}
 
void Initizlize() {
  CHECK_EQ(mode_, NONE);
  mode_ = DefaultMode();
}


void SetMode(Mode mode) {
   mode_ = mode;
}

to uninitialize it

SetMode(NONE);

This can be different depending on how much strict you want to do. For example,
it may be better to set "default mode", then let Initialize initialize with it.
That way, you can make test code close to production code.

+
+  // Declarations only. Do not allow construction of an object.
+  MaterialDesignController();
+  ~MaterialDesignController();
+
+  // Returns the per-platform default material design variant.
+  static bool DefaultMode();
+
+  // Sets |mode_| to |mode| and updates |is_mode_initialized_| to true. Can be
+  // used by tests to directly set the mode.
+  static void SetMode(bool mode);
+
+  // Resets the initialization state to uninitialized. To be used by tests to
+  // allow calling Initialize() more than once.
+  static void Uninitialize();
+
+  DISALLOW_COPY_AND_ASSIGN(MaterialDesignController);
+};
+
+}  // namespace ash
+
+#endif  // ASH_MATERIAL_DESIGN_MATERIAL_DESIGN_CONTROLLER_H_