gpu: Remove GL_TEXTURE_POOL_CHROMIUM

The distinction between "managed" and "unmanaged" is not used anywhere
anymore.

The behavior of EnsureGPUMemoryAvailable might appear to be affected by
this, but all implementations always return true. Arguably this should
be removed as well.

BUG=
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1399493003

Cr-Commit-Position: refs/heads/master@{#353418}

18 files changed, 92 insertions, 260 deletions

diff --git a/gpu/GLES2/gl2extchromium.h b/gpu/GLES2/gl2extchromium.h
index 51928a3..a79b3e7 100644
--- a/gpu/GLES2/gl2extchromium.h
+++ b/gpu/GLES2/gl2extchromium.h
@@ -27,23 +27,6 @@ typedef void (GL_APIENTRYP PFNGLTEXIMAGEIOSURFACE2DCHROMIUMPROC) (
     GLuint plane);
 #endif  /* GL_CHROMIUM_iosurface */
 
-/* GL_CHROMIUM_gpu_memory_manager */
-#ifndef GL_CHROMIUM_gpu_memory_manager
-#define GL_CHROMIUM_gpu_memory_manager 1
-
-#ifndef GL_TEXTURE_POOL_UNMANAGED_CHROMIUM
-#define GL_TEXTURE_POOL_UNMANAGED_CHROMIUM 0x6002
-#endif
-
-#ifndef GL_TEXTURE_POOL_CHROMIUM
-#define GL_TEXTURE_POOL_CHROMIUM 0x6000
-#endif
-
-#ifndef GL_TEXTURE_POOL_MANAGED_CHROMIUM
-#define GL_TEXTURE_POOL_MANAGED_CHROMIUM 0x6001
-#endif
-#endif  /* GL_CHROMIUM_gpu_memory_manager */
-
 /* GL_CHROMIUM_texture_mailbox */
 #ifndef GL_CHROMIUM_texture_mailbox
 #define GL_CHROMIUM_texture_mailbox 1
diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py
index e726958..5affdcb 100755
--- a/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -1346,7 +1346,6 @@ _NAMED_TYPE_INFO = {
     'valid': [
       'GL_TEXTURE_MAG_FILTER',
       'GL_TEXTURE_MIN_FILTER',
-      'GL_TEXTURE_POOL_CHROMIUM',
       'GL_TEXTURE_WRAP_S',
       'GL_TEXTURE_WRAP_T',
     ],
@@ -1365,13 +1364,6 @@ _NAMED_TYPE_INFO = {
       'GL_GENERATE_MIPMAP',
     ],
   },
-  'TexturePool': {
-    'type': 'GLenum',
-    'valid': [
-      'GL_TEXTURE_POOL_MANAGED_CHROMIUM',
-      'GL_TEXTURE_POOL_UNMANAGED_CHROMIUM',
-    ],
-  },
   'TextureWrapMode': {
     'type': 'GLenum',
     'valid': [
diff --git a/gpu/command_buffer/common/gles2_cmd_utils_autogen.h b/gpu/command_buffer/common/gles2_cmd_utils_autogen.h
index e23d2c4..fb1bd4a 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_utils_autogen.h
@@ -85,7 +85,6 @@ static std::string GetStringTextureInternalFormatStorage(uint32_t value);
 static std::string GetStringTextureMagFilterMode(uint32_t value);
 static std::string GetStringTextureMinFilterMode(uint32_t value);
 static std::string GetStringTextureParameter(uint32_t value);
-static std::string GetStringTexturePool(uint32_t value);
 static std::string GetStringTextureTarget(uint32_t value);
 static std::string GetStringTextureUsage(uint32_t value);
 static std::string GetStringTextureWrapMode(uint32_t value);
diff --git a/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h b/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
index af2b10e..82c83fa 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
@@ -49,9 +49,6 @@ static const GLES2Util::EnumToString enum_to_string_table[] = {
         0x0BC2, "GL_ALPHA_TEST_REF_QCOM",
     },
     {
-        0x78EF, "GL_PIXEL_UNPACK_TRANSFER_BUFFER_BINDING_CHROMIUM",
-    },
-    {
         0x884D, "GL_TEXTURE_COMPARE_FUNC_EXT",
     },
     {
@@ -1159,9 +1156,6 @@ static const GLES2Util::EnumToString enum_to_string_table[] = {
         0x8A44, "GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER",
     },
     {
-        0x6000, "GL_TEXTURE_POOL_CHROMIUM",
-    },
-    {
         0x0B74, "GL_DEPTH_FUNC",
     },
     {
@@ -2266,9 +2260,6 @@ static const GLES2Util::EnumToString enum_to_string_table[] = {
         0x84DC, "GL_TEXTURE28",
     },
     {
-        0x6002, "GL_TEXTURE_POOL_UNMANAGED_CHROMIUM",
-    },
-    {
         0x84DA, "GL_TEXTURE26",
     },
     {
@@ -2845,7 +2836,7 @@ static const GLES2Util::EnumToString enum_to_string_table[] = {
         0x78EE, "GL_PIXEL_PACK_TRANSFER_BUFFER_BINDING_CHROMIUM",
     },
     {
-        0x6001, "GL_TEXTURE_POOL_MANAGED_CHROMIUM",
+        0x78EF, "GL_PIXEL_UNPACK_TRANSFER_BUFFER_BINDING_CHROMIUM",
     },
     {
         0x0B45, "GL_CULL_FACE_MODE",
@@ -4641,7 +4632,6 @@ std::string GLES2Util::GetStringTextureParameter(uint32_t value) {
   static const EnumToString string_table[] = {
       {GL_TEXTURE_MAG_FILTER, "GL_TEXTURE_MAG_FILTER"},
       {GL_TEXTURE_MIN_FILTER, "GL_TEXTURE_MIN_FILTER"},
-      {GL_TEXTURE_POOL_CHROMIUM, "GL_TEXTURE_POOL_CHROMIUM"},
       {GL_TEXTURE_WRAP_S, "GL_TEXTURE_WRAP_S"},
       {GL_TEXTURE_WRAP_T, "GL_TEXTURE_WRAP_T"},
       {GL_TEXTURE_BASE_LEVEL, "GL_TEXTURE_BASE_LEVEL"},
@@ -4658,16 +4648,6 @@ std::string GLES2Util::GetStringTextureParameter(uint32_t value) {
                                            arraysize(string_table), value);
 }
 
-std::string GLES2Util::GetStringTexturePool(uint32_t value) {
-  static const EnumToString string_table[] = {
-      {GL_TEXTURE_POOL_MANAGED_CHROMIUM, "GL_TEXTURE_POOL_MANAGED_CHROMIUM"},
-      {GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
-       "GL_TEXTURE_POOL_UNMANAGED_CHROMIUM"},
-  };
-  return GLES2Util::GetQualifiedEnumString(string_table,
-                                           arraysize(string_table), value);
-}
-
 std::string GLES2Util::GetStringTextureTarget(uint32_t value) {
   static const EnumToString string_table[] = {
       {GL_TEXTURE_2D, "GL_TEXTURE_2D"},
diff --git a/gpu/command_buffer/service/buffer_manager.cc b/gpu/command_buffer/service/buffer_manager.cc
index 6e3c167..20806e2 100644
--- a/gpu/command_buffer/service/buffer_manager.cc
+++ b/gpu/command_buffer/service/buffer_manager.cc
@@ -24,7 +24,7 @@ namespace gles2 {
 BufferManager::BufferManager(MemoryTracker* memory_tracker,
                              FeatureInfo* feature_info)
     : memory_type_tracker_(
-          new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)),
+          new MemoryTypeTracker(memory_tracker)),
       memory_tracker_(memory_tracker),
       feature_info_(feature_info),
       allow_buffers_on_multiple_targets_(false),
diff --git a/gpu/command_buffer/service/buffer_manager_unittest.cc b/gpu/command_buffer/service/buffer_manager_unittest.cc
index 91003a0..faf7828 100644
--- a/gpu/command_buffer/service/buffer_manager_unittest.cc
+++ b/gpu/command_buffer/service/buffer_manager_unittest.cc
@@ -102,9 +102,9 @@ class BufferManagerClientSideArraysTest : public BufferManagerTestBase {
   scoped_refptr<FeatureInfo> feature_info_;
 };
 
-#define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size, pool)   \
+#define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size)   \
   EXPECT_CALL(*mock_memory_tracker_.get(),                          \
-              TrackMemoryAllocatedChange(old_size, new_size, pool)) \
+              TrackMemoryAllocatedChange(old_size, new_size)) \
       .Times(1).RetiresOnSaturation()
 
 TEST_F(BufferManagerTest, Basic) {
@@ -154,22 +154,22 @@ TEST_F(BufferManagerMemoryTrackerTest, Basic) {
   const GLsizeiptr kBuffer1Size1 = 123;
   const GLsizeiptr kBuffer1Size2 = 456;
   // Check we can create buffer.
-  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kManaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0);
   manager_->CreateBuffer(kClientBuffer1Id, kServiceBuffer1Id);
   // Check buffer got created.
   Buffer* buffer1 = manager_->GetBuffer(kClientBuffer1Id);
   ASSERT_TRUE(buffer1 != NULL);
   manager_->SetTarget(buffer1, kTarget);
   // Check we and set its size.
-  EXPECT_MEMORY_ALLOCATION_CHANGE(0, kBuffer1Size1, MemoryTracker::kManaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, kBuffer1Size1);
   DoBufferData(
       buffer1, kTarget, kBuffer1Size1, GL_DYNAMIC_DRAW, NULL, GL_NO_ERROR);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(kBuffer1Size1, 0, MemoryTracker::kManaged);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(0, kBuffer1Size2, MemoryTracker::kManaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(kBuffer1Size1, 0);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, kBuffer1Size2);
   DoBufferData(
       buffer1, kTarget, kBuffer1Size2, GL_DYNAMIC_DRAW, NULL, GL_NO_ERROR);
   // On delete it will get freed.
-  EXPECT_MEMORY_ALLOCATION_CHANGE(kBuffer1Size2, 0, MemoryTracker::kManaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(kBuffer1Size2, 0);
 }
 
 TEST_F(BufferManagerTest, Destroy) {
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index a555557..626e362 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -2534,7 +2534,7 @@ ScopedResolvedFrameBufferBinder::~ScopedResolvedFrameBufferBinder() {
 BackTexture::BackTexture(
     MemoryTracker* memory_tracker,
     ContextState* state)
-    : memory_tracker_(memory_tracker, MemoryTracker::kUnmanaged),
+    : memory_tracker_(memory_tracker),
       state_(state),
       bytes_allocated_(0),
       id_(0) {
@@ -2647,7 +2647,7 @@ BackRenderbuffer::BackRenderbuffer(
     MemoryTracker* memory_tracker,
     ContextState* state)
     : renderbuffer_manager_(renderbuffer_manager),
-      memory_tracker_(memory_tracker, MemoryTracker::kUnmanaged),
+      memory_tracker_(memory_tracker),
       state_(state),
       bytes_allocated_(0),
       id_(0) {
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
index a66af3a..3f6d20d 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
@@ -1111,65 +1111,27 @@ TEST_P(GLES2DecoderTest, IsEnabledReturnsCachedValue) {
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, GpuMemoryManagerCHROMIUM) {
-  InitState init;
-  init.extensions = "GL_ARB_texture_rectangle";
-  init.bind_generates_resource = true;
-  InitDecoder(init);
-
-  Texture* texture = GetTexture(client_texture_id_)->texture();
-  EXPECT_TRUE(texture != NULL);
-  EXPECT_TRUE(texture->pool() == GL_TEXTURE_POOL_UNMANAGED_CHROMIUM);
-
-  DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
-
-  TexParameteri cmd;
-  cmd.Init(GL_TEXTURE_2D,
-           GL_TEXTURE_POOL_CHROMIUM,
-           GL_TEXTURE_POOL_UNMANAGED_CHROMIUM);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-
-  cmd.Init(GL_TEXTURE_2D,
-           GL_TEXTURE_POOL_CHROMIUM,
-           GL_TEXTURE_POOL_MANAGED_CHROMIUM);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-
-  EXPECT_TRUE(texture->pool() == GL_TEXTURE_POOL_MANAGED_CHROMIUM);
-
-  cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_POOL_CHROMIUM, GL_NONE);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
-}
-
 namespace {
 
 class SizeOnlyMemoryTracker : public MemoryTracker {
  public:
   SizeOnlyMemoryTracker() {
-    // These are the default textures. 1 for TEXTURE_2D and 6 faces for
-    // TEXTURE_CUBE_MAP.
-    const size_t kInitialUnmanagedPoolSize = 7 * 4;
-    const size_t kInitialManagedPoolSize = 0;
-    pool_infos_[MemoryTracker::kUnmanaged].initial_size =
-        kInitialUnmanagedPoolSize;
-    pool_infos_[MemoryTracker::kManaged].initial_size = kInitialManagedPoolSize;
+    // Account for the 7 default textures. 1 for TEXTURE_2D and 6 faces for
+    // TEXTURE_CUBE_MAP. Each is 1x1, with 4 bytes per channel.
+    pool_info_.initial_size = 28;
+    pool_info_.size = 0;
   }
 
   // Ensure a certain amount of GPU memory is free. Returns true on success.
   MOCK_METHOD1(EnsureGPUMemoryAvailable, bool(size_t size_needed));
 
   virtual void TrackMemoryAllocatedChange(size_t old_size,
-                                          size_t new_size,
-                                          Pool pool) {
-    PoolInfo& info = pool_infos_[pool];
-    info.size += new_size - old_size;
+                                          size_t new_size) {
+    pool_info_.size += new_size - old_size;
   }
 
-  size_t GetPoolSize(Pool pool) {
-    const PoolInfo& info = pool_infos_[pool];
-    return info.size - info.initial_size;
+  size_t GetPoolSize() {
+    return pool_info_.size - pool_info_.initial_size;
   }
 
   uint64_t ClientTracingId() const override { return 0; }
@@ -1183,7 +1145,7 @@ class SizeOnlyMemoryTracker : public MemoryTracker {
     size_t initial_size;
     size_t size;
   };
-  std::map<Pool, PoolInfo> pool_infos_;
+  PoolInfo pool_info_;
 };
 
 }  // anonymous namespace.
@@ -1196,8 +1158,8 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerInitialSize) {
   init.bind_generates_resource = true;
   InitDecoder(init);
   // Expect that initial size - size is 0.
-  EXPECT_EQ(0u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
-  EXPECT_EQ(0u, memory_tracker->GetPoolSize(MemoryTracker::kManaged));
+  EXPECT_EQ(0u, memory_tracker->GetPoolSize());
+  EXPECT_EQ(0u, memory_tracker->GetPoolSize());
 }
 
 TEST_P(GLES2DecoderManualInitTest, MemoryTrackerTexImage2D) {
@@ -1221,7 +1183,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerTexImage2D) {
                GL_UNSIGNED_BYTE,
                kSharedMemoryId,
                kSharedMemoryOffset);
-  EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
+  EXPECT_EQ(128u, memory_tracker->GetPoolSize());
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(64))
       .WillOnce(Return(true))
       .RetiresOnSaturation();
@@ -1235,7 +1197,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerTexImage2D) {
                GL_UNSIGNED_BYTE,
                kSharedMemoryId,
                kSharedMemoryOffset);
-  EXPECT_EQ(64u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
+  EXPECT_EQ(64u, memory_tracker->GetPoolSize());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   // Check we get out of memory and no call to glTexImage2D if Ensure fails.
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(64))
@@ -1253,7 +1215,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerTexImage2D) {
            kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
-  EXPECT_EQ(64u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
+  EXPECT_EQ(64u, memory_tracker->GetPoolSize());
 }
 
 TEST_P(GLES2DecoderManualInitTest, MemoryTrackerTexStorage2DEXT) {
@@ -1272,7 +1234,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerTexStorage2DEXT) {
   TexStorage2DEXT cmd;
   cmd.Init(GL_TEXTURE_2D, 1, GL_RGBA8, 8, 4);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(0u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
+  EXPECT_EQ(0u, memory_tracker->GetPoolSize());
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
 }
 
@@ -1307,7 +1269,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerCopyTexImage2D) {
   CopyTexImage2D cmd;
   cmd.Init(target, level, internal_format, 0, 0, width, height);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
+  EXPECT_EQ(128u, memory_tracker->GetPoolSize());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   // Check we get out of memory and no call to glCopyTexImage2D if Ensure fails.
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
@@ -1315,7 +1277,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerCopyTexImage2D) {
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
-  EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
+  EXPECT_EQ(128u, memory_tracker->GetPoolSize());
 }
 
 TEST_P(GLES2DecoderManualInitTest, MemoryTrackerRenderbufferStorage) {
@@ -1342,7 +1304,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerRenderbufferStorage) {
   cmd.Init(GL_RENDERBUFFER, GL_RGBA4, 8, 4);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
+  EXPECT_EQ(128u, memory_tracker->GetPoolSize());
   // Check we get out of memory and no call to glRenderbufferStorage if Ensure
   // fails.
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
@@ -1350,7 +1312,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerRenderbufferStorage) {
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
-  EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
+  EXPECT_EQ(128u, memory_tracker->GetPoolSize());
 }
 
 TEST_P(GLES2DecoderManualInitTest, MemoryTrackerBufferData) {
@@ -1360,6 +1322,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerBufferData) {
   InitState init;
   init.bind_generates_resource = true;
   InitDecoder(init);
+  EXPECT_EQ(0u, memory_tracker->GetPoolSize());
   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
@@ -1375,7 +1338,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerBufferData) {
   cmd.Init(GL_ARRAY_BUFFER, 128, 0, 0, GL_STREAM_DRAW);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kManaged));
+  EXPECT_EQ(128u, memory_tracker->GetPoolSize());
   // Check we get out of memory and no call to glBufferData if Ensure
   // fails.
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
@@ -1383,7 +1346,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerBufferData) {
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
-  EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kManaged));
+  EXPECT_EQ(128u, memory_tracker->GetPoolSize());
 }
 
 TEST_P(GLES2DecoderManualInitTest, ImmutableCopyTexImage2D) {
diff --git a/gpu/command_buffer/service/gles2_cmd_validation_autogen.h b/gpu/command_buffer/service/gles2_cmd_validation_autogen.h
index 229987d..71c0e03 100644
--- a/gpu/command_buffer/service/gles2_cmd_validation_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_validation_autogen.h
@@ -88,7 +88,6 @@ ValueValidator<GLenum> texture_internal_format_storage;
 ValueValidator<GLenum> texture_mag_filter_mode;
 ValueValidator<GLenum> texture_min_filter_mode;
 ValueValidator<GLenum> texture_parameter;
-ValueValidator<GLenum> texture_pool;
 ValueValidator<GLenum> texture_target;
 ValueValidator<GLenum> texture_usage;
 ValueValidator<GLenum> texture_wrap_mode;
diff --git a/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h b/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
index ea6a90e..aa05581 100644
--- a/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
@@ -854,8 +854,8 @@ static const GLenum valid_texture_min_filter_mode_table[] = {
 };
 
 static const GLenum valid_texture_parameter_table[] = {
-    GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_TEXTURE_POOL_CHROMIUM,
-    GL_TEXTURE_WRAP_S,     GL_TEXTURE_WRAP_T,
+    GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_TEXTURE_WRAP_S,
+    GL_TEXTURE_WRAP_T,
 };
 
 static const GLenum valid_texture_parameter_table_es3[] = {
@@ -866,10 +866,6 @@ static const GLenum valid_texture_parameter_table_es3[] = {
     GL_TEXTURE_WRAP_R,
 };
 
-static const GLenum valid_texture_pool_table[] = {
-    GL_TEXTURE_POOL_MANAGED_CHROMIUM, GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
-};
-
 static const GLenum valid_texture_target_table[] = {
     GL_TEXTURE_2D,
     GL_TEXTURE_CUBE_MAP_POSITIVE_X,
@@ -1086,8 +1082,6 @@ Validators::Validators()
                               arraysize(valid_texture_min_filter_mode_table)),
       texture_parameter(valid_texture_parameter_table,
                         arraysize(valid_texture_parameter_table)),
-      texture_pool(valid_texture_pool_table,
-                   arraysize(valid_texture_pool_table)),
       texture_target(valid_texture_target_table,
                      arraysize(valid_texture_target_table)),
       texture_usage(valid_texture_usage_table,
diff --git a/gpu/command_buffer/service/memory_tracking.h b/gpu/command_buffer/service/memory_tracking.h
index 14bf29c..5b0cd22 100644
--- a/gpu/command_buffer/service/memory_tracking.h
+++ b/gpu/command_buffer/service/memory_tracking.h
@@ -18,14 +18,8 @@ namespace gles2 {
 // statistics to the global GpuMemoryManager.
 class MemoryTracker : public base::RefCounted<MemoryTracker> {
  public:
-   enum Pool {
-     kUnmanaged,
-     kManaged
-   };
-
    virtual void TrackMemoryAllocatedChange(size_t old_size,
-                                           size_t new_size,
-                                           Pool pool) = 0;
+                                           size_t new_size) = 0;
 
    // Ensure a certain amount of GPU memory is free. Returns true on success.
    virtual bool EnsureGPUMemoryAvailable(size_t size_needed) = 0;
@@ -54,9 +48,8 @@ class MemoryTracker : public base::RefCounted<MemoryTracker> {
 // MemoryTracker.
 class MemoryTypeTracker {
  public:
-  MemoryTypeTracker(MemoryTracker* memory_tracker, MemoryTracker::Pool pool)
+  MemoryTypeTracker(MemoryTracker* memory_tracker)
     : memory_tracker_(memory_tracker),
-      pool_(pool),
       has_done_update_(false),
       mem_represented_(0),
       mem_represented_at_last_update_(0) {
@@ -100,15 +93,13 @@ class MemoryTypeTracker {
     if (memory_tracker_) {
       memory_tracker_->TrackMemoryAllocatedChange(
         mem_represented_at_last_update_,
-        mem_represented_,
-        pool_);
+        mem_represented_);
     }
     has_done_update_ = true;
     mem_represented_at_last_update_ = mem_represented_;
   }
 
   MemoryTracker* memory_tracker_;
-  MemoryTracker::Pool pool_;
   bool has_done_update_;
   size_t mem_represented_;
   size_t mem_represented_at_last_update_;
diff --git a/gpu/command_buffer/service/mocks.h b/gpu/command_buffer/service/mocks.h
index b503ce0..0824d8e 100644
--- a/gpu/command_buffer/service/mocks.h
+++ b/gpu/command_buffer/service/mocks.h
@@ -142,8 +142,8 @@ class MockMemoryTracker : public MemoryTracker {
  public:
   MockMemoryTracker();
 
-  MOCK_METHOD3(TrackMemoryAllocatedChange, void(
-      size_t old_size, size_t new_size, Pool pool));
+  MOCK_METHOD2(TrackMemoryAllocatedChange, void(
+      size_t old_size, size_t new_size));
   MOCK_METHOD1(EnsureGPUMemoryAvailable, bool(size_t size_needed));
   MOCK_CONST_METHOD0(ClientTracingId, uint64_t());
   MOCK_CONST_METHOD0(ClientId, int());
diff --git a/gpu/command_buffer/service/renderbuffer_manager.cc b/gpu/command_buffer/service/renderbuffer_manager.cc
index 54c18be..d9c82ae 100644
--- a/gpu/command_buffer/service/renderbuffer_manager.cc
+++ b/gpu/command_buffer/service/renderbuffer_manager.cc
@@ -49,7 +49,7 @@ RenderbufferManager::RenderbufferManager(MemoryTracker* memory_tracker,
                                          GLint max_samples,
                                          FeatureInfo* feature_info)
     : memory_type_tracker_(
-          new MemoryTypeTracker(memory_tracker, MemoryTracker::kUnmanaged)),
+          new MemoryTypeTracker(memory_tracker)),
       memory_tracker_(memory_tracker),
       max_renderbuffer_size_(max_renderbuffer_size),
       max_samples_(max_samples),
diff --git a/gpu/command_buffer/service/renderbuffer_manager_unittest.cc b/gpu/command_buffer/service/renderbuffer_manager_unittest.cc
index 9957203..beebe0e 100644
--- a/gpu/command_buffer/service/renderbuffer_manager_unittest.cc
+++ b/gpu/command_buffer/service/renderbuffer_manager_unittest.cc
@@ -72,9 +72,9 @@ class RenderbufferManagerMemoryTrackerTest
   scoped_refptr<MockMemoryTracker> mock_memory_tracker_;
 };
 
-#define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size, pool)   \
-  EXPECT_CALL(*mock_memory_tracker_.get(),                          \
-              TrackMemoryAllocatedChange(old_size, new_size, pool)) \
+#define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size)   \
+  EXPECT_CALL(*mock_memory_tracker_.get(),                    \
+              TrackMemoryAllocatedChange(old_size, new_size)) \
       .Times(1).RetiresOnSaturation()
 
 // GCC requires these declarations, but MSVC requires they not be present
@@ -180,7 +180,7 @@ TEST_F(RenderbufferManagerTest, Renderbuffer) {
 TEST_F(RenderbufferManagerMemoryTrackerTest, Basic) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
-  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0);
   manager_->CreateRenderbuffer(kClient1Id, kService1Id);
   Renderbuffer* renderbuffer1 =
       manager_->GetRenderbuffer(kClient1Id);
@@ -197,16 +197,12 @@ TEST_F(RenderbufferManagerMemoryTrackerTest, Basic) {
       kWidth, kHeight1, kSamples, kFormat, &expected_size_1);
   manager_->ComputeEstimatedRenderbufferSize(
       kWidth, kHeight2, kSamples, kFormat, &expected_size_2);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(
-      0, expected_size_1, MemoryTracker::kUnmanaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, expected_size_1);
   manager_->SetInfo(renderbuffer1, kSamples, kFormat, kWidth, kHeight1);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(
-      expected_size_1, 0, MemoryTracker::kUnmanaged);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(
-      0, expected_size_2, MemoryTracker::kUnmanaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(expected_size_1, 0);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, expected_size_2);
   manager_->SetInfo(renderbuffer1, kSamples, kFormat, kWidth, kHeight2);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(
-      expected_size_2, 0, MemoryTracker::kUnmanaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(expected_size_2, 0);
   EXPECT_CALL(*gl_, DeleteRenderbuffersEXT(1, ::testing::Pointee(kService1Id)))
       .Times(1)
       .RetiresOnSaturation();
diff --git a/gpu/command_buffer/service/test_helper.cc b/gpu/command_buffer/service/test_helper.cc
index 4b8d8fc..edc6662 100644
--- a/gpu/command_buffer/service/test_helper.cc
+++ b/gpu/command_buffer/service/test_helper.cc
@@ -822,12 +822,10 @@ void TestHelper::SetTexParameteriWithExpectations(
     TextureManager* manager, TextureRef* texture_ref,
     GLenum pname, GLint value, GLenum error) {
   if (error == GL_NO_ERROR) {
-    if (pname != GL_TEXTURE_POOL_CHROMIUM) {
-      EXPECT_CALL(*gl, TexParameteri(texture_ref->texture()->target(),
-                                     pname, value))
-          .Times(1)
-          .RetiresOnSaturation();
-    }
+    EXPECT_CALL(*gl, TexParameteri(texture_ref->texture()->target(),
+                                   pname, value))
+        .Times(1)
+        .RetiresOnSaturation();
   } else if (error == GL_INVALID_ENUM) {
     EXPECT_CALL(*error_state, SetGLErrorInvalidEnum(_, _, _, value, _))
         .Times(1)
diff --git a/gpu/command_buffer/service/texture_manager.cc b/gpu/command_buffer/service/texture_manager.cc
index db8921f..716bedc 100644
--- a/gpu/command_buffer/service/texture_manager.cc
+++ b/gpu/command_buffer/service/texture_manager.cc
@@ -302,8 +302,7 @@ void TextureManager::Destroy(bool have_context) {
     glDeleteTextures(arraysize(black_texture_ids_), black_texture_ids_);
   }
 
-  DCHECK_EQ(0u, memory_tracker_managed_->GetMemRepresented());
-  DCHECK_EQ(0u, memory_tracker_unmanaged_->GetMemRepresented());
+  DCHECK_EQ(0u, memory_type_tracker_->GetMemRepresented());
 }
 
 Texture::Texture(GLuint service_id)
@@ -320,7 +319,6 @@ Texture::Texture(GLuint service_id)
       wrap_s_(GL_REPEAT),
       wrap_t_(GL_REPEAT),
       usage_(GL_NONE),
-      pool_(GL_TEXTURE_POOL_UNMANAGED_CHROMIUM),
       compare_func_(GL_LEQUAL),
       compare_mode_(GL_NONE),
       max_lod_(1000.0f),
@@ -381,7 +379,7 @@ void Texture::RemoveTextureRef(TextureRef* ref, bool have_context) {
 
 MemoryTypeTracker* Texture::GetMemTracker() {
   DCHECK(memory_tracking_ref_);
-  return memory_tracking_ref_->manager()->GetMemTracker(pool_);
+  return memory_tracking_ref_->manager()->GetMemTracker();
 }
 
 Texture::LevelInfo::LevelInfo()
@@ -953,14 +951,6 @@ GLenum Texture::SetParameteri(
       }
       mag_filter_ = param;
       break;
-    case GL_TEXTURE_POOL_CHROMIUM:
-      if (!feature_info->validators()->texture_pool.IsValid(param)) {
-        return GL_INVALID_ENUM;
-      }
-      GetMemTracker()->TrackMemFree(estimated_size());
-      pool_ = param;
-      GetMemTracker()->TrackMemAlloc(estimated_size());
-      break;
     case GL_TEXTURE_WRAP_R:
       if (!feature_info->validators()->texture_wrap_mode.IsValid(param)) {
         return GL_INVALID_ENUM;
@@ -1029,7 +1019,6 @@ GLenum Texture::SetParameterf(
   switch (pname) {
     case GL_TEXTURE_MIN_FILTER:
     case GL_TEXTURE_MAG_FILTER:
-    case GL_TEXTURE_POOL_CHROMIUM:
     case GL_TEXTURE_WRAP_R:
     case GL_TEXTURE_WRAP_S:
     case GL_TEXTURE_WRAP_T:
@@ -1365,10 +1354,7 @@ TextureManager::TextureManager(MemoryTracker* memory_tracker,
                                GLint max_rectangle_texture_size,
                                GLint max_3d_texture_size,
                                bool use_default_textures)
-    : memory_tracker_managed_(
-          new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)),
-      memory_tracker_unmanaged_(
-          new MemoryTypeTracker(memory_tracker, MemoryTracker::kUnmanaged)),
+    : memory_type_tracker_(new MemoryTypeTracker(memory_tracker)),
       memory_tracker_(memory_tracker),
       feature_info_(feature_info),
       framebuffer_manager_(NULL),
@@ -1614,11 +1600,7 @@ void TextureManager::SetParameteri(
           error_state, result, function_name, pname, param);
     }
   } else {
-    // Texture tracking pools exist only for the command decoder, so
-    // do not pass them on to the native GL implementation.
-    if (pname != GL_TEXTURE_POOL_CHROMIUM) {
-      glTexParameteri(texture->target(), pname, param);
-    }
+    glTexParameteri(texture->target(), pname, param);
   }
 }
 
@@ -1638,11 +1620,7 @@ void TextureManager::SetParameterf(
           error_state, result, function_name, pname, param);
     }
   } else {
-    // Texture tracking pools exist only for the command decoder, so
-    // do not pass them on to the native GL implementation.
-    if (pname != GL_TEXTURE_POOL_CHROMIUM) {
-      glTexParameterf(texture->target(), pname, param);
-    }
+    glTexParameterf(texture->target(), pname, param);
   }
 }
 
@@ -1719,19 +1697,8 @@ void TextureManager::StopTracking(TextureRef* ref) {
   DCHECK_GE(num_uncleared_mips_, 0);
 }
 
-MemoryTypeTracker* TextureManager::GetMemTracker(GLenum tracking_pool) {
-  switch (tracking_pool) {
-    case GL_TEXTURE_POOL_MANAGED_CHROMIUM:
-      return memory_tracker_managed_.get();
-      break;
-    case GL_TEXTURE_POOL_UNMANAGED_CHROMIUM:
-      return memory_tracker_unmanaged_.get();
-      break;
-    default:
-      break;
-  }
-  NOTREACHED();
-  return NULL;
+MemoryTypeTracker* TextureManager::GetMemTracker() {
+  return memory_type_tracker_.get();
 }
 
 Texture* TextureManager::GetTextureForServiceId(GLuint service_id) const {
@@ -1962,7 +1929,7 @@ bool TextureManager::ValidateTexImage(
     return false;
   }
 
-  if (!memory_tracker_managed_->EnsureGPUMemoryAvailable(args.pixels_size)) {
+  if (!memory_type_tracker_->EnsureGPUMemoryAvailable(args.pixels_size)) {
     ERRORSTATE_SET_GL_ERROR(error_state, GL_OUT_OF_MEMORY, function_name,
                             "out of memory");
     return false;
@@ -2015,7 +1982,7 @@ void TextureManager::ValidateAndDoTexImage(
     }
 
     DCHECK(undefined_faces.size());
-    if (!memory_tracker_managed_->EnsureGPUMemoryAvailable(
+    if (!memory_type_tracker_->EnsureGPUMemoryAvailable(
             undefined_faces.size() * args.pixels_size)) {
       ERRORSTATE_SET_GL_ERROR(state->GetErrorState(), GL_OUT_OF_MEMORY,
                               function_name, "out of memory");
diff --git a/gpu/command_buffer/service/texture_manager.h b/gpu/command_buffer/service/texture_manager.h
index ab5cf4d..a04cfa2 100644
--- a/gpu/command_buffer/service/texture_manager.h
+++ b/gpu/command_buffer/service/texture_manager.h
@@ -65,10 +65,6 @@ class GPU_EXPORT Texture {
     return usage_;
   }
 
-  GLenum pool() const {
-    return pool_;
-  }
-
   GLenum compare_func() const {
     return compare_func_;
   }
@@ -439,7 +435,6 @@ class GPU_EXPORT Texture {
   GLenum wrap_s_;
   GLenum wrap_t_;
   GLenum usage_;
-  GLenum pool_;
   GLenum compare_func_;
   GLenum compare_mode_;
   GLfloat max_lod_;
@@ -792,9 +787,7 @@ class GPU_EXPORT TextureManager : public base::trace_event::MemoryDumpProvider {
   }
 
   size_t mem_represented() const {
-    return
-        memory_tracker_managed_->GetMemRepresented() +
-        memory_tracker_unmanaged_->GetMemRepresented();
+    return memory_type_tracker_->GetMemRepresented();
   }
 
   void SetLevelImage(
@@ -910,9 +903,8 @@ class GPU_EXPORT TextureManager : public base::trace_event::MemoryDumpProvider {
   void DumpTextureRef(base::trace_event::ProcessMemoryDump* pmd,
                       TextureRef* ref);
 
-  MemoryTypeTracker* GetMemTracker(GLenum texture_pool);
-  scoped_ptr<MemoryTypeTracker> memory_tracker_managed_;
-  scoped_ptr<MemoryTypeTracker> memory_tracker_unmanaged_;
+  MemoryTypeTracker* GetMemTracker();
+  scoped_ptr<MemoryTypeTracker> memory_type_tracker_;
   MemoryTracker* memory_tracker_;
 
   scoped_refptr<FeatureInfo> feature_info_;
diff --git a/gpu/command_buffer/service/texture_manager_unittest.cc b/gpu/command_buffer/service/texture_manager_unittest.cc
index 262faab..90e90c4 100644
--- a/gpu/command_buffer/service/texture_manager_unittest.cc
+++ b/gpu/command_buffer/service/texture_manager_unittest.cc
@@ -550,9 +550,9 @@ class TextureMemoryTrackerTest : public TextureTestBase {
   scoped_refptr<MockMemoryTracker> mock_memory_tracker_;
 };
 
-#define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size, pool)   \
-  EXPECT_CALL(*mock_memory_tracker_.get(),                          \
-              TrackMemoryAllocatedChange(old_size, new_size, pool)) \
+#define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size)   \
+  EXPECT_CALL(*mock_memory_tracker_.get(),                    \
+              TrackMemoryAllocatedChange(old_size, new_size)) \
       .Times(1).RetiresOnSaturation()
 
 TEST_F(TextureTest, Basic) {
@@ -623,33 +623,16 @@ TEST_F(TextureTest, EstimatedSize) {
 
 TEST_F(TextureMemoryTrackerTest, EstimatedSize) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128);
   manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1,
                          0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(8, 4));
-  EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 256, MemoryTracker::kUnmanaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 256);
   manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 2, GL_RGBA, 8, 4, 1,
                          0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(8, 4));
   // Add expectation for texture deletion.
-  EXPECT_MEMORY_ALLOCATION_CHANGE(256, 0, MemoryTracker::kUnmanaged);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
-}
-
-TEST_F(TextureMemoryTrackerTest, SetParameterPool) {
-  manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged);
-  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1,
-                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(8, 4));
-  EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kManaged);
-  SetParameter(texture_ref_.get(),
-               GL_TEXTURE_POOL_CHROMIUM,
-               GL_TEXTURE_POOL_MANAGED_CHROMIUM,
-               GL_NO_ERROR);
-  // Add expectation for texture deletion.
-  EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kManaged);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kManaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(256, 0);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0);
 }
 
 TEST_F(TextureTest, POT2D) {
@@ -703,14 +686,14 @@ TEST_F(TextureTest, POT2D) {
 
 TEST_F(TextureMemoryTrackerTest, MarkMipmapsGenerated) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 64, MemoryTracker::kUnmanaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 64);
   manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1,
                          0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 4));
-  EXPECT_MEMORY_ALLOCATION_CHANGE(64, 0, MemoryTracker::kUnmanaged);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 84, MemoryTracker::kUnmanaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(64, 0);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 84);
   EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
-  EXPECT_MEMORY_ALLOCATION_CHANGE(84, 0, MemoryTracker::kUnmanaged);
-  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(84, 0);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0);
 }
 
 TEST_F(TextureTest, UnusedMips) {
@@ -1804,22 +1787,18 @@ TEST_F(ProduceConsumeTextureTest, ProduceConsumeCube) {
 class CountingMemoryTracker : public MemoryTracker {
  public:
   CountingMemoryTracker() {
-    current_size_[0] = 0;
-    current_size_[1] = 0;
+    current_size_ = 0;
   }
 
   void TrackMemoryAllocatedChange(size_t old_size,
-                                  size_t new_size,
-                                  Pool pool) override {
-    DCHECK_LT(static_cast<size_t>(pool), arraysize(current_size_));
-    current_size_[pool] += new_size - old_size;
+                                  size_t new_size) override {
+    current_size_ += new_size - old_size;
   }
 
   bool EnsureGPUMemoryAvailable(size_t size_needed) override { return true; }
 
-  size_t GetSize(Pool pool) {
-    DCHECK_LT(static_cast<size_t>(pool), arraysize(current_size_));
-    return current_size_[pool];
+  size_t GetSize() {
+    return current_size_;
   }
 
   uint64_t ClientTracingId() const override { return 0; }
@@ -1831,7 +1810,7 @@ class CountingMemoryTracker : public MemoryTracker {
  private:
   ~CountingMemoryTracker() override {}
 
-  size_t current_size_[2];
+  size_t current_size_;
   DISALLOW_COPY_AND_ASSIGN(CountingMemoryTracker);
 };
 
@@ -2026,8 +2005,8 @@ TEST_F(SharedTextureTest, FBOCompletenessCheck) {
 }
 
 TEST_F(SharedTextureTest, Memory) {
-  size_t initial_memory1 = memory_tracker1_->GetSize(MemoryTracker::kUnmanaged);
-  size_t initial_memory2 = memory_tracker2_->GetSize(MemoryTracker::kUnmanaged);
+  size_t initial_memory1 = memory_tracker1_->GetSize();
+  size_t initial_memory2 = memory_tracker2_->GetSize();
 
   // Newly created texture is unrenderable.
   scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
@@ -2037,24 +2016,23 @@ TEST_F(SharedTextureTest, Memory) {
 
   EXPECT_LT(0u, ref1->texture()->estimated_size());
   EXPECT_EQ(initial_memory1 + ref1->texture()->estimated_size(),
-            memory_tracker1_->GetSize(MemoryTracker::kUnmanaged));
+            memory_tracker1_->GetSize());
 
   // Associate new texture ref to other texture manager, it doesn't account for
   // the texture memory, the first memory tracker still has it.
   scoped_refptr<TextureRef> ref2 =
       texture_manager2_->Consume(20, ref1->texture());
   EXPECT_EQ(initial_memory1 + ref1->texture()->estimated_size(),
-            memory_tracker1_->GetSize(MemoryTracker::kUnmanaged));
-  EXPECT_EQ(initial_memory2,
-            memory_tracker2_->GetSize(MemoryTracker::kUnmanaged));
+            memory_tracker1_->GetSize());
+  EXPECT_EQ(initial_memory2, memory_tracker2_->GetSize());
 
   // Delete the texture, memory should go to the remaining tracker.
   texture_manager1_->RemoveTexture(10);
   ref1 = NULL;
   EXPECT_EQ(initial_memory1,
-            memory_tracker1_->GetSize(MemoryTracker::kUnmanaged));
+            memory_tracker1_->GetSize());
   EXPECT_EQ(initial_memory2 + ref2->texture()->estimated_size(),
-            memory_tracker2_->GetSize(MemoryTracker::kUnmanaged));
+            memory_tracker2_->GetSize());
 
   EXPECT_CALL(*gl_, DeleteTextures(1, _))
       .Times(1)
@@ -2062,7 +2040,7 @@ TEST_F(SharedTextureTest, Memory) {
   ref2 = NULL;
   texture_manager2_->RemoveTexture(20);
   EXPECT_EQ(initial_memory2,
-            memory_tracker2_->GetSize(MemoryTracker::kUnmanaged));
+            memory_tracker2_->GetSize());
 }
 
 TEST_F(SharedTextureTest, Images) {