diff --git a/CMakeLists.txt b/CMakeLists.txt
index ef881df..9b7c29a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -424,7 +424,8 @@
   # made search variables visible in GUI for user to set, but then user disables
   # GFLAGS instead of setting them.
   MARK_AS_ADVANCED(FORCE GFLAGS_INCLUDE_DIR
-                         GFLAGS_LIBRARY)
+                         GFLAGS_LIBRARY
+                         GFLAGS_NAMESPACE)
 ENDIF (GFLAGS)
 
 # MiniGLog.
diff --git a/cmake/FindGflags.cmake b/cmake/FindGflags.cmake
index 5d89bb0..99d461e 100644
--- a/cmake/FindGflags.cmake
+++ b/cmake/FindGflags.cmake
@@ -72,11 +72,16 @@
   UNSET(GFLAGS_FOUND)
   UNSET(GFLAGS_INCLUDE_DIRS)
   UNSET(GFLAGS_LIBRARIES)
-  UNSET(GFLAGS_NAMESPACE)
+  # Do not use unset, as we want to keep GFLAGS_NAMESPACE in the cache,
+  # but simply clear its value.
+  SET(GFLAGS_NAMESPACE "" CACHE STRING
+    "gflags namespace (google or gflags)" FORCE)
+
   # Make results of search visible in the CMake GUI if gflags has not
   # been found so that user does not have to toggle to advanced view.
   MARK_AS_ADVANCED(CLEAR GFLAGS_INCLUDE_DIR
-                         GFLAGS_LIBRARY)
+                         GFLAGS_LIBRARY
+                         GFLAGS_NAMESPACE)
   # Note <package>_FIND_[REQUIRED/QUIETLY] variables defined by FindPackage()
   # use the camelcase library name, not uppercase.
   IF (Gflags_FIND_QUIETLY)
@@ -90,6 +95,88 @@
   ENDIF ()
 ENDMACRO(GFLAGS_REPORT_NOT_FOUND)
 
+# A cut down version of CMake's check_cxx_source_compiles() macro, which
+# supports specification of the CMAKE_BUILD_TYPE with which the test should
+# be compiled (but not REGEX matching of the output).  This is important
+# on Windows, for at least the NMake generator, which otherwise chooses
+# Debug, when the gflags library will typically be compiled in Release, and
+# MSVC will then fail to build, thus making all check_cxx_source_compiles()
+# tests fail.
+#
+# As per the CMake check_cxx_source_compiles() macro, we assume the following
+# variables can be set before this is invoked:
+#
+#    CMAKE_REQUIRED_FLAGS - String of compile command line flags.
+#    CMAKE_REQUIRED_DEFINITIONS - List of macros to define (-DFOO=bar).
+#    CMAKE_REQUIRED_INCLUDES - List of include directories.
+#    CMAKE_REQUIRED_LIBRARIES - List of libraries to link.
+#
+# This macro is a derivative of the CMake check_cxx_source_compiles() macro
+# distributed under the BSD License, Copyright 2005-2009 Kitware, Inc.
+MACRO(CHECK_CXX_SOURCE_COMPILES_WITH_BUILD_TYPE
+    SOURCE BUILD_TYPE VAR)
+  # Do not rerun test if output variable has an assigned value, ie is not
+  # an empty string.
+  IF ("${VAR}" MATCHES "^${VAR}$")
+    # Verify that the BUILD_TYPE is sane.
+    IF (NOT "${BUILD_TYPE}" STREQUAL "Release" AND
+        NOT "${BUILD_TYPE}" STREQUAL "Debug" AND
+        NOT "${BUILD_TYPE}" STREQUAL "RelWithDebInfo" AND
+        NOT "${BUILD_TYPE}" STREQUAL "MinSizeRel" AND
+        NOT "${BUILD_TYPE}" STREQUAL "")
+      MESSAGE(FATAL_ERROR "Invalid BUILD_TYPE: ${BUILD_TYPE}, is not a "
+        "valid CMAKE_BUILD_TYPE option.")
+    ENDIF()
+
+    SET(MACRO_CHECK_FUNCTION_DEFINITIONS
+      "-D${VAR} ${CMAKE_REQUIRED_FLAGS}")
+
+    SET(CHECK_CXX_SOURCE_COMPILES_ADD_LIBRARIES)
+    IF (CMAKE_REQUIRED_LIBRARIES)
+      SET(CHECK_CXX_SOURCE_COMPILES_ADD_LIBRARIES
+        LINK_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
+    ENDIF()
+
+    SET(CHECK_CXX_SOURCE_COMPILES_ADD_INCLUDES)
+    IF (CMAKE_REQUIRED_INCLUDES)
+      SET(CHECK_CXX_SOURCE_COMPILES_ADD_INCLUDES
+        "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}")
+    ENDIF()
+
+    FILE(WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.cxx"
+      "${SOURCE}\n")
+
+    MESSAGE(STATUS "Performing Test ${VAR}")
+    # Pass the CMAKE_BUILD_TYPE to the CMake test project created to execute
+    # the test (main difference over CMake's check_cxx_source_compiles() macro).
+    TRY_COMPILE(${VAR}
+      ${CMAKE_BINARY_DIR}
+      ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.cxx
+      COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
+      ${CHECK_CXX_SOURCE_COMPILES_ADD_LIBRARIES}
+      CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
+      "-DCMAKE_BUILD_TYPE:STRING=${BUILD_TYPE}"
+      "${CHECK_CXX_SOURCE_COMPILES_ADD_INCLUDES}"
+      OUTPUT_VARIABLE OUTPUT)
+
+    IF (${VAR})
+      MESSAGE(STATUS "Performing Test ${VAR} - Success")
+      SET(${VAR} 1 CACHE INTERNAL "Test ${VAR}")
+      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+        "Performing C++ SOURCE FILE Test ${VAR} succeded with the following output:\n"
+        "${OUTPUT}\n"
+        "Source file was:\n${SOURCE}\n")
+    ELSE()
+      MESSAGE(STATUS "Performing Test ${VAR} - Failed")
+      SET(${VAR} "" CACHE INTERNAL "Test ${VAR}")
+      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+        "Performing C++ SOURCE FILE Test ${VAR} failed with the following output:\n"
+        "${OUTPUT}\n"
+        "Source file was:\n${SOURCE}\n")
+    ENDIF()
+  ENDIF()
+ENDMACRO()
+
 # Search user-installed locations first, so that we prefer user installs
 # to system installs where both exist.
 #
@@ -130,53 +217,156 @@
 ENDIF (NOT GFLAGS_LIBRARY OR
        NOT EXISTS ${GFLAGS_LIBRARY})
 
+# gflags typically requires a threading library (which is OS dependent), note
+# that this defines the CMAKE_THREAD_LIBS_INIT variable.  If we are able to
+# detect threads, we assume that gflags requires it.
+FIND_PACKAGE(Threads QUIET)
+SET(GFLAGS_LINK_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
+# On Windows, the Shlwapi library is used by gflags if available.
+IF (MSVC)
+  INCLUDE(CheckIncludeFileCXX)
+  CHECK_INCLUDE_FILE_CXX("shlwapi.h" HAVE_SHLWAPI)
+  IF (HAVE_SHLWAPI)
+    LIST(APPEND GFLAGS_LINK_LIBRARIES shlwapi.lib)
+  ENDIF(HAVE_SHLWAPI)
+ENDIF (MSVC)
+
 # Mark internally as found, then verify. GFLAGS_REPORT_NOT_FOUND() unsets
 # if called.
 SET(GFLAGS_FOUND TRUE)
 
 # Identify what namespace gflags was built with.
-IF (GFLAGS_INCLUDE_DIR)
-  # First try the (older) google namespace.
-  INCLUDE(CheckCXXSourceCompiles)
-  # Setup include path & link library for gflags for CHECK_CXX_SOURCE_COMPILES
-  SET(CMAKE_REQUIRED_INCLUDES ${GFLAGS_INCLUDE_DIR})
-  SET(CMAKE_REQUIRED_LIBRARIES ${GFLAGS_LIBRARY})
-  CHECK_CXX_SOURCE_COMPILES(
-    "#include <gflags/gflags.h>
+IF (GFLAGS_INCLUDE_DIR AND NOT GFLAGS_NAMESPACE)
+  # To handle Windows peculiarities / CMake bugs on MSVC we try two approaches
+  # to detect the gflags namespace:
+  #
+  # 1) Try to use a custom version of check_cxx_source_compiles():
+  #    check_cxx_source_compiles_with_build_type(),
+  #    to compile a trivial program with the two choices for the gflags
+  #    namespace.
+  #
+  #    This works on all OSs except Windows.  On Windows, if using NMake
+  #    generator the previous method also works, if using Visual Studio, it does
+  #    not, because our explicit instruction regarding the CMAKE_BUILD_TYPE is
+  #    ignored by msbuild.  This breaks detection because MSVC requires that the
+  #    build type of the test project used by check_cxx_source_compiles() match
+  #    that of gflags.  However, msbuild forces the test project to use Debug,
+  #    but gflags will be built in Release.
+  #
+  # 2) [In the event 1) fails] Use regex on the gflags.h header file to try to
+  #    determine the gflags namespace.  Whilst this is less robust than 1),
+  #    it does avoid any interaction with msbuild.
+
+  # On Windows, it is required that the build type of the test app match that
+  # of gflags, as CMAKE_BUILD_TYPE may not be defined when this is called, we
+  # try each in turn.
+  LIST(APPEND TEST_BUILD_TYPES Release Debug)
+  FOREACH(BUILD_TYPE ${TEST_BUILD_TYPES})
+    STRING(TOUPPER "${BUILD_TYPE}" BUILD_TYPE_UPPERCASE)
+    # Setup include path & link library for gflags for CHECK_CXX_SOURCE_COMPILES.
+    SET(CMAKE_REQUIRED_INCLUDES ${GFLAGS_INCLUDE_DIR})
+    SET(CMAKE_REQUIRED_LIBRARIES ${GFLAGS_LIBRARY} ${GFLAGS_LINK_LIBRARIES})
+    # First try the (older) google namespace.  Note that the output variable
+    # MUST be unique to the build type as otherwise the test is not repeated as
+    # it is assumed to have already been performed.
+    CHECK_CXX_SOURCE_COMPILES_WITH_BUILD_TYPE(
+      "#include <gflags/gflags.h>
      int main(int argc, char * argv[]) {
        google::ParseCommandLineFlags(&argc, &argv, true);
        return 0;
      }"
-     GFLAGS_IN_GOOGLE_NAMESPACE)
-  IF (GFLAGS_IN_GOOGLE_NAMESPACE)
-    SET(GFLAGS_NAMESPACE google)
-  ELSE (GFLAGS_IN_GOOGLE_NAMESPACE)
-    # Try (newer) gflags namespace instead.
-    #
-    # Setup include path & link library for gflags for CHECK_CXX_SOURCE_COMPILES
-    SET(CMAKE_REQUIRED_INCLUDES ${GFLAGS_INCLUDE_DIR})
-    SET(CMAKE_REQUIRED_LIBRARIES ${GFLAGS_LIBRARY})
-    CHECK_CXX_SOURCE_COMPILES(
-      "#include <gflags/gflags.h>
+     ${BUILD_TYPE}
+     GFLAGS_IN_GOOGLE_NAMESPACE_${BUILD_TYPE_UPPERCASE})
+   IF (GFLAGS_IN_GOOGLE_NAMESPACE_${BUILD_TYPE_UPPERCASE})
+     SET(GFLAGS_NAMESPACE google)
+     BREAK()
+   ELSE (GFLAGS_IN_GOOGLE_NAMESPACE_${BUILD_TYPE_UPPERCASE})
+     # Try (newer) gflags namespace instead.  Note that the output variable
+     # MUST be unique to the build type as otherwise the test is not repeated as
+     # it is assumed to have already been performed.
+     SET(CMAKE_REQUIRED_INCLUDES ${GFLAGS_INCLUDE_DIR})
+     SET(CMAKE_REQUIRED_LIBRARIES ${GFLAGS_LIBRARY} ${GFLAGS_LINK_LIBRARIES})
+     CHECK_CXX_SOURCE_COMPILES_WITH_BUILD_TYPE(
+       "#include <gflags/gflags.h>
        int main(int argc, char * argv[]) {
          gflags::ParseCommandLineFlags(&argc, &argv, true);
          return 0;
        }"
-       GFLAGS_IN_GFLAGS_NAMESPACE)
-    IF (GFLAGS_IN_GFLAGS_NAMESPACE)
-      SET(GFLAGS_NAMESPACE gflags)
-    ENDIF (GFLAGS_IN_GFLAGS_NAMESPACE)
-  ENDIF (GFLAGS_IN_GOOGLE_NAMESPACE)
+       ${BUILD_TYPE}
+       GFLAGS_IN_GFLAGS_NAMESPACE_${BUILD_TYPE_UPPERCASE})
+     IF (GFLAGS_IN_GFLAGS_NAMESPACE_${BUILD_TYPE_UPPERCASE})
+       SET(GFLAGS_NAMESPACE gflags)
+       BREAK()
+     ENDIF (GFLAGS_IN_GFLAGS_NAMESPACE_${BUILD_TYPE_UPPERCASE})
+   ENDIF (GFLAGS_IN_GOOGLE_NAMESPACE_${BUILD_TYPE_UPPERCASE})
+ ENDFOREACH()
 
-  IF (NOT GFLAGS_NAMESPACE)
-    GFLAGS_REPORT_NOT_FOUND(
-      "Failed to determine gflags namespace, it is not google or gflags.")
-  ENDIF (NOT GFLAGS_NAMESPACE)
-ENDIF (GFLAGS_INCLUDE_DIR)
+ IF (NOT GFLAGS_NAMESPACE)
+   # Failed to determine gflags namespace using
+   # check_cxx_source_compiles_with_build_type() method, try and obtain it
+   # using regex on the gflags header instead.
+   MESSAGE(STATUS "Failed to find gflags namespace using using "
+     "check_cxx_source_compiles(), trying namespace regex instead, "
+     "this is expected on Windows.")
+   # Scan gflags.h to identify what namespace gflags was built with.
+   SET(GFLAGS_HEADER_FILE ${GFLAGS_INCLUDE_DIR}/gflags/gflags.h)
+   IF (NOT EXISTS ${GFLAGS_HEADER_FILE})
+     GFLAGS_REPORT_NOT_FOUND(
+       "Could not find file: ${GFLAGS_HEADER_FILE} "
+       "containing namespace information in gflags install located at: "
+       "${GFLAGS_INCLUDE_DIR}.")
+   ELSE (NOT EXISTS ${GFLAGS_HEADER_FILE})
+     FILE(READ ${GFLAGS_HEADER_FILE} GFLAGS_HEADER_FILE_CONTENTS)
+
+     STRING(REGEX MATCH "namespace [A-Za-z]+"
+       GFLAGS_NAMESPACE "${GFLAGS_HEADER_FILE_CONTENTS}")
+     STRING(REGEX REPLACE "namespace ([A-Za-z]+)" "\\1"
+       GFLAGS_NAMESPACE "${GFLAGS_NAMESPACE}")
+
+     IF (NOT GFLAGS_NAMESPACE)
+      GFLAGS_REPORT_NOT_FOUND(
+        "Failed to extract gflags namespace from header file: "
+        "${GFLAGS_HEADER_FILE}.")
+     ENDIF (NOT GFLAGS_NAMESPACE)
+
+     # Verify that the namespace is either google or gflags.  Strictly
+     # speaking the users can specify something else when building gflags,
+     # but doing so would cause so many compatibility issues, that they should
+     # not have done, so any mismatch is almost certainly a regex failure.
+     IF (NOT GFLAGS_NAMESPACE STREQUAL "google" AND
+         NOT GFLAGS_NAMESPACE STREQUAL "gflags")
+       GFLAGS_REPORT_NOT_FOUND(
+         "Failed to extract valid gflags namespace from header file: "
+         "${GFLAGS_HEADER_FILE}, result: ${GFLAGS_NAMESPACE} is not "
+         "google or gflags.")
+     ENDIF()
+   ENDIF (NOT EXISTS ${GFLAGS_HEADER_FILE})
+ ENDIF (NOT GFLAGS_NAMESPACE)
+
+ IF (NOT GFLAGS_NAMESPACE)
+   GFLAGS_REPORT_NOT_FOUND(
+     "Failed to determine gflags namespace either by "
+     "check_cxx_source_compiles(), or namespace regex.")
+ ENDIF (NOT GFLAGS_NAMESPACE)
+ENDIF (GFLAGS_INCLUDE_DIR AND NOT GFLAGS_NAMESPACE)
+
+# Make the GFLAGS_NAMESPACE a cache variable s/t the user can view it, and could
+# overwrite it in the CMake GUI.
+SET(GFLAGS_NAMESPACE "${GFLAGS_NAMESPACE}" CACHE STRING
+  "gflags namespace (google or gflags)" FORCE)
 
 # gflags does not seem to provide any record of the version in its
 # source tree, thus cannot extract version.
 
+# Catch case when caller has set GFLAGS_NAMESPACE in the cache / GUI
+# with an invalid value.
+IF (GFLAGS_NAMESPACE AND
+    NOT GFLAGS_NAMESPACE STREQUAL "google" AND
+    NOT GFLAGS_NAMESPACE STREQUAL "gflags")
+  GFLAGS_REPORT_NOT_FOUND(
+    "Caller defined GFLAGS_NAMESPACE:"
+    " ${GFLAGS_NAMESPACE} is not valid, not google or gflags.")
+ENDIF ()
 # Catch case when caller has set GFLAGS_INCLUDE_DIR in the cache / GUI and
 # thus FIND_[PATH/LIBRARY] are not called, but specified locations are
 # invalid, otherwise we would report the library as found.
@@ -202,7 +392,7 @@
 # Set standard CMake FindPackage variables if found.
 IF (GFLAGS_FOUND)
   SET(GFLAGS_INCLUDE_DIRS ${GFLAGS_INCLUDE_DIR})
-  SET(GFLAGS_LIBRARIES ${GFLAGS_LIBRARY})
+  SET(GFLAGS_LIBRARIES ${GFLAGS_LIBRARY} ${GFLAGS_LINK_LIBRARIES})
 ENDIF (GFLAGS_FOUND)
 
 # Handle REQUIRED / QUIET optional arguments.