diff --git a/internal/ceres/dogleg_strategy.cc b/internal/ceres/dogleg_strategy.cc
index 44d484f..4b1f074 100644
--- a/internal/ceres/dogleg_strategy.cc
+++ b/internal/ceres/dogleg_strategy.cc
@@ -71,7 +71,7 @@
 // gradient) and the new Gauss-Newton step are computed from
 // scratch. The Dogleg step is then computed as interpolation of these
 // two vectors.
-LinearSolver::Summary DoglegStrategy::ComputeStep(
+TrustRegionStrategy::Summary DoglegStrategy::ComputeStep(
     const TrustRegionStrategy::PerSolveOptions& per_solve_options,
     SparseMatrix* jacobian,
     const double* residuals,
@@ -85,10 +85,10 @@
     // Gauss-Newton and gradient vectors are always available, only a
     // new interpolant need to be computed.
     ComputeDoglegStep(step);
-    LinearSolver::Summary linear_solver_summary;
-    linear_solver_summary.num_iterations = 0;
-    linear_solver_summary.termination_type = TOLERANCE;
-    return linear_solver_summary;
+    TrustRegionStrategy::Summary summary;
+    summary.num_iterations = 0;
+    summary.termination_type = TOLERANCE;
+    return summary;
   }
 
   reuse_ = true;
@@ -123,7 +123,11 @@
     ComputeDoglegStep(step);
   }
 
-  return linear_solver_summary;
+  TrustRegionStrategy::Summary summary;
+  summary.residual_norm = linear_solver_summary.residual_norm;
+  summary.num_iterations = linear_solver_summary.num_iterations;
+  summary.termination_type = linear_solver_summary.termination_type;
+  return summary;
 }
 
 // The trust region is assumed to be elliptical with the
diff --git a/internal/ceres/dogleg_strategy.h b/internal/ceres/dogleg_strategy.h
index 1505655..8c2ff7b 100644
--- a/internal/ceres/dogleg_strategy.h
+++ b/internal/ceres/dogleg_strategy.h
@@ -53,11 +53,10 @@
   virtual ~DoglegStrategy() {}
 
   // TrustRegionStrategy interface
-  virtual LinearSolver::Summary ComputeStep(
-      const TrustRegionStrategy::PerSolveOptions& per_solve_options,
-      SparseMatrix* jacobian,
-      const double* residuals,
-      double* step);
+  virtual Summary ComputeStep(const PerSolveOptions& per_solve_options,
+                              SparseMatrix* jacobian,
+                              const double* residuals,
+                              double* step);
   virtual void StepAccepted(double step_quality);
   virtual void StepRejected(double step_quality);
   virtual void StepIsInvalid();
diff --git a/internal/ceres/levenberg_marquardt_strategy.cc b/internal/ceres/levenberg_marquardt_strategy.cc
index 576648a..af76c42 100644
--- a/internal/ceres/levenberg_marquardt_strategy.cc
+++ b/internal/ceres/levenberg_marquardt_strategy.cc
@@ -61,7 +61,7 @@
 LevenbergMarquardtStrategy::~LevenbergMarquardtStrategy() {
 }
 
-LinearSolver::Summary LevenbergMarquardtStrategy::ComputeStep(
+TrustRegionStrategy::Summary LevenbergMarquardtStrategy::ComputeStep(
     const TrustRegionStrategy::PerSolveOptions& per_solve_options,
     SparseMatrix* jacobian,
     const double* residuals,
@@ -113,7 +113,12 @@
   }
 
   reuse_diagonal_ = true;
-  return linear_solver_summary;
+
+  TrustRegionStrategy::Summary summary;
+  summary.residual_norm = linear_solver_summary.residual_norm;
+  summary.num_iterations = linear_solver_summary.num_iterations;
+  summary.termination_type = linear_solver_summary.termination_type;
+  return summary;
 }
 
 void LevenbergMarquardtStrategy::StepAccepted(double step_quality) {
diff --git a/internal/ceres/levenberg_marquardt_strategy.h b/internal/ceres/levenberg_marquardt_strategy.h
index 4ed1390..90c2178 100644
--- a/internal/ceres/levenberg_marquardt_strategy.h
+++ b/internal/ceres/levenberg_marquardt_strategy.h
@@ -31,7 +31,7 @@
 #ifndef CERES_INTERNAL_LEVENBERG_MARQUARDT_STRATEGY_H_
 #define CERES_INTERNAL_LEVENBERG_MARQUARDT_STRATEGY_H_
 
-#include "ceres/linear_solver.h"
+#include "ceres/internal/eigen.h"
 #include "ceres/trust_region_strategy.h"
 
 namespace ceres {
@@ -48,7 +48,7 @@
   virtual ~LevenbergMarquardtStrategy();
 
   // TrustRegionStrategy interface
-  virtual LinearSolver::Summary ComputeStep(
+  virtual TrustRegionStrategy::Summary ComputeStep(
       const TrustRegionStrategy::PerSolveOptions& per_solve_options,
       SparseMatrix* jacobian,
       const double* residuals,
diff --git a/internal/ceres/levenberg_marquardt_strategy_test.cc b/internal/ceres/levenberg_marquardt_strategy_test.cc
index 22f04aa..6f61dd1 100644
--- a/internal/ceres/levenberg_marquardt_strategy_test.cc
+++ b/internal/ceres/levenberg_marquardt_strategy_test.cc
@@ -28,14 +28,15 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
-
+#include "ceres/internal/eigen.h"
+#include "ceres/internal/scoped_ptr.h"
+#include "ceres/levenberg_marquardt_strategy.h"
+#include "ceres/linear_solver.h"
+#include "ceres/trust_region_strategy.h"
 #include "glog/logging.h"
 #include "gmock/gmock.h"
 #include "gmock/mock-log.h"
 #include "gtest/gtest.h"
-#include "ceres/trust_region_strategy.h"
-#include "ceres/levenberg_marquardt_strategy.h"
-#include "ceres/internal/eigen.h"
 
 using testing::AllOf;
 using testing::AnyNumber;
@@ -147,7 +148,7 @@
     EXPECT_CALL(log, Log(WARNING, _,
                          HasSubstr("Failed to compute a finite step.")));
 
-    LinearSolver::Summary summary = lms.ComputeStep(pso, &dsm, &residual, x);
+    TrustRegionStrategy::Summary summary = lms.ComputeStep(pso, &dsm, &residual, x);
     EXPECT_EQ(summary.termination_type, FAILURE);
   }
 }
diff --git a/internal/ceres/trust_region_minimizer.cc b/internal/ceres/trust_region_minimizer.cc
index 476cc9d..19e3f35 100644
--- a/internal/ceres/trust_region_minimizer.cc
+++ b/internal/ceres/trust_region_minimizer.cc
@@ -250,7 +250,7 @@
     const time_t strategy_start_time = time(NULL);
     TrustRegionStrategy::PerSolveOptions per_solve_options;
     per_solve_options.eta = options_.eta;
-    LinearSolver::Summary strategy_summary =
+    TrustRegionStrategy::Summary strategy_summary =
         strategy->ComputeStep(per_solve_options,
                               jacobian,
                               residuals.data(),
diff --git a/internal/ceres/trust_region_strategy.h b/internal/ceres/trust_region_strategy.h
index 8d5977e..7d94ca2 100644
--- a/internal/ceres/trust_region_strategy.h
+++ b/internal/ceres/trust_region_strategy.h
@@ -31,11 +31,14 @@
 #ifndef CERES_INTERNAL_TRUST_REGION_STRATEGY_H_
 #define CERES_INTERNAL_TRUST_REGION_STRATEGY_H_
 
-#include "ceres/linear_solver.h"
+#include "ceres/types.h"
 
 namespace ceres {
 namespace internal {
 
+class LinearSolver;
+class SparseMatrix;
+
 // Interface for classes implementing various trust region strategies
 // for nonlinear least squares problems.
 //
@@ -79,14 +82,38 @@
     double eta;
   };
 
+  struct Summary {
+    Summary()
+        : residual_norm(0.0),
+          num_iterations(-1),
+          termination_type(FAILURE) {
+    }
+
+    // If the trust region problem is,
+    //
+    //   1/2 x'Ax + b'x + c,
+    //
+    // then
+    //
+    //   residual_norm = |Ax -b|
+    double residual_norm;
+
+    // Number of iterations used by the linear solver. If a linear
+    // solver was not called (e.g., DogLegStrategy after an
+    // unsuccessful step), then this would be zero.
+    int num_iterations;
+
+    // Status of the linear solver used to solve the Newton system.
+    LinearSolverTerminationType termination_type;
+  };
+
   virtual ~TrustRegionStrategy();
 
   // Use the current radius to solve for the trust region step.
-  virtual LinearSolver::Summary ComputeStep(
-      const PerSolveOptions& per_solve_options,
-      SparseMatrix* jacobian,
-      const double* residuals,
-      double* step) = 0;
+  virtual Summary ComputeStep(const PerSolveOptions& per_solve_options,
+                              SparseMatrix* jacobian,
+                              const double* residuals,
+                              double* step) = 0;
 
   // Inform the strategy that the current step has been accepted, and
   // that the ratio of the decrease in the non-linear objective to the